Merge pull request #695 from kszucs/aiopeewee

aiopeewee example

.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

@@ -12,4 +12,7 @@ settings.py
 .cache/*
 .python-version
 docs/_build/
-docs/_api/
+docs/_api/
+build/*
+access.log
+error.log

.travis.yml

@@ -12,3 +12,4 @@ deploy:
     secure: OgADRQH3+dTL5swGzXkeRJDNbLpFzwqYnXB4iLD0Npvzj9QnKyQVvkbaeq6VmV9dpEFb5ULaAKYQq19CrXYDm28yanUSn6jdJ4SukaHusi7xt07U6H7pmoX/uZ2WZYqCSLM8cSp8TXY/3oV3rY5Jfj/AibE5XTbim5/lrhsvW6NR+ALzxc0URRPAHDZEPpojTCjSTjpY0aDsaKWg4mXVRMFfY3O68j6KaIoukIZLuoHfePLKrbZxaPG5VxNhMHEaICdxVxE/dO+7pQmQxXuIsEOHK1QiVJ9YrSGcNqgEqhN36kYP8dqMeVB07sv8Xa6o/Uax2/wXS2HEJvuwP1YD6WkoZuo9ZB85bcMdg7BV9jJDbVFVPJwc75BnTLHrMa3Q1KrRlKRDBUXBUsQivPuWhFNwUgvEayq2qSI3aRQR4Z0O+DfboEhXYojSoD64/EWBTZ7vhgbvOTGEdukUQSYrKj9P8jc1s8exomTsAiqdFxTUpzfiammUSL+M93lP4urtahl1jjXFX7gd3DzdEEb0NsGkx5lm/qdsty8/TeAvKUmC+RVU6T856W6MqN0P+yGbpWUARcSE7fwztC3SPxwAuxvIN3BHmRhOUHoORPNG2VpfbnscIzBKJR4v0JKzbpi0IDa66K+tCGsCEvQuL4cxVOtoUySPWNSUAyUWWUrGM2k=
   on:
     tags: true
+  distributions: "sdist bdist_wheel"

CONTRIBUTING.md

@@ -0,0 +1,62 @@
+# 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.
+
+## Installation
+
+To develop on sanic (and mainly to just run the tests) it is highly recommend to
+install from sources.
+
+So assume you have already cloned the repo and are in the working directory with
+a virtual environment already set up, then run:
+
+```bash
+python setup.py develop && pip install -r requirements-dev.txt
+```
+
+## Running tests
+
+To run the tests for sanic it is recommended to use tox like so:
+
+```bash
+tox
+```
+
+See it's that simple!
+
+## Pull requests!
+
+So the pull request approval rules are pretty simple:
+1. All pull requests must pass unit tests
+2. All pull requests must be reviewed and approved by at least 
+one current collaborator on the project
+3. All pull requests must pass flake8 checks
+4. If you decide to remove/change anything from any common interface
+a deprecation message should accompany it.
+5. If you implement a new feature you should have at least one unit
+test to accompany it.
+
+## 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.

Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.6
+
+ADD . /app
+WORKDIR /app
+
+RUN pip install tox

MANIFEST.in

@@ -0,0 +1,4 @@
+include README.rst
+
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]

Makefile

@@ -0,0 +1,4 @@
+test:
+	find . -name "*.pyc" -delete
+	docker build -t sanic/test-image .
+	docker run -t sanic/test-image tox

README.rst

@@ -1,5 +1,5 @@
 Sanic
-=================================
+=====
 
 |Join the chat at https://gitter.im/sanic-python/Lobby| |Build Status| |PyPI| |PyPI version|
 
@@ -9,6 +9,8 @@ On top of being Flask-like, Sanic supports async request handlers.  This means y
 
 Sanic is developed `on GitHub <https://github.com/channelcat/sanic/>`_. Contributions are welcome!
 
+If you have a project that utilizes Sanic make sure to comment on the `issue <https://github.com/channelcat/sanic/issues/396>`_ that we use to track those projects!
+
 Benchmarks
 ----------
 
@@ -59,6 +61,13 @@ Installation
 
 -  ``python -m pip install sanic``
 
+To install sanic without uvloop or json using bash, you can provide either or both of these environmental variables
+using any truthy string like `'y', 'yes', 't', 'true', 'on', '1'` and setting the NO_X to true will stop that features
+installation.
+
+- ``SANIC_NO_UVLOOP=true SANIC_NO_UJSON=true python -m pip install sanic``
+
+
 Documentation
 -------------
 
@@ -77,10 +86,8 @@ Documentation
 
 TODO
 ----
-* Streamed file processing
-* File output
-* Examples of integrations with 3rd-party modules
-* RESTful router
+ * Streamed file processing
+ * http2
 
 Limitations
 -----------

docs/conf.py

@@ -22,7 +22,7 @@ import sanic
 
 # -- General configuration ------------------------------------------------
 
-extensions = []
+extensions = ['sphinx.ext.autodoc']
 
 templates_path = ['_templates']
 
@@ -68,7 +68,6 @@ 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
@@ -80,13 +79,11 @@ html_theme = 'sphinx_rtd_theme'
 # 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 = {
@@ -110,21 +107,14 @@ latex_elements = {
 # 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'),
-]
-
+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)
-]
-
+man_pages = [(master_doc, 'sanic', 'Sanic Documentation', [author], 1)]
 
 # -- Options for Texinfo output -------------------------------------------
 
@@ -132,13 +122,10 @@ man_pages = [
 # (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'),
+    (master_doc, 'Sanic', 'Sanic Documentation', author, 'Sanic',
+     'One line description of project.', 'Miscellaneous'),
 ]
 
-
-
 # -- Options for Epub output ----------------------------------------------
 
 # Bibliographic Dublin Core info.
@@ -150,8 +137,6 @@ 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/index.rst

@@ -9,15 +9,18 @@ Guides
    sanic/getting_started
    sanic/routing
    sanic/request_data
+   sanic/response
    sanic/static_files
    sanic/exceptions
    sanic/middleware
    sanic/blueprints
    sanic/config
    sanic/cookies
+   sanic/streaming
    sanic/class_based_views
    sanic/custom_protocol
    sanic/ssl
+   sanic/logging
    sanic/testing
    sanic/deploying
    sanic/extensions

docs/sanic/blueprints.md

@@ -55,13 +55,18 @@ will look like:
 
 Blueprints have much the same functionality as an application instance.
 
+### WebSocket routes
+
+WebSocket handlers can be registered on a blueprint using the `@bp.websocket`
+decorator or `bp.add_websocket_route` method.
+
 ### Middleware
 
 Using blueprints allows you to also register middleware globally.
 
 ```python
 @bp.middleware
-async def halt_request(request):
+async def print_on_request(request):
 	print("I am a spy")
 
 @bp.middleware('request')
@@ -111,7 +116,7 @@ bp = Blueprint('my_blueprint')
 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()
@@ -131,13 +136,13 @@ can be used to implement our API versioning scheme.
 from sanic.response import text
 from sanic import Blueprint
 
-blueprint_v1 = Blueprint('v1')
-blueprint_v2 = Blueprint('v2')
+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')
@@ -153,8 +158,8 @@ from sanic import Sanic
 from blueprints import blueprint_v1, blueprint_v2
 
 app = Sanic(__name__)
-app.blueprint(blueprint_v1)
-app.blueprint(blueprint_v2)
+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)
 ```
@@ -167,7 +172,7 @@ 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)
+    url = app.url_for('v1.post_handler', post_id=5) # --> '/v1/post/5'
     return redirect(url)
 
 

docs/sanic/class_based_views.md

@@ -48,6 +48,24 @@ app.add_route(SimpleView.as_view(), '/')
 
 ```
 
+You can also use `async` syntax.
+
+```python
+from sanic import Sanic
+from sanic.views import HTTPMethodView
+from sanic.response import text
+
+app = Sanic('some_name')
+
+class SimpleAsyncView(HTTPMethodView):
+
+  async def get(self, request):
+      return text('I am async get method')
+
+app.add_route(SimpleAsyncView.as_view(), '/')
+
+```
+
 ## URL parameters
 
 If you need any URL parameters, as discussed in the routing guide, include them
@@ -128,4 +146,4 @@ view.add(['POST', 'PUT'], lambda request: text('I am a post/put method'))
 app.add_route(view, '/')
 ```
 
-Note: currently you cannot build a URL for a CompositionView using `url_for`. 
+Note: currently you cannot build a URL for a CompositionView using `url_for`.

docs/sanic/config.md

@@ -1,6 +1,6 @@
 # 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.
+Any reasonably complex application will need configuration that is not baked into the actual code. Settings might be different for different environments or installations.
 
 ## Basics
 
@@ -29,6 +29,14 @@ In general the convention is to only have UPPERCASE configuration parameters. Th
 
 There are several ways how to load configuration.
 
+### From environment variables.
+
+Any variables defined with the `SANIC_` prefix will be applied to the sanic config. For example, setting `SANIC_REQUEST_TIMEOUT` will be loaded by the application automatically. You can pass the `load_vars` boolean to the Sanic constructor to override that:
+
+```python
+app = Sanic(load_vars=False)
+```
+
 ### 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:
@@ -71,8 +79,8 @@ DB_USER = 'appuser'
 
 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) |
-
+    | Variable          | Default   | Description                       |
+    | ----------------- | --------- | --------------------------------- |
+    | REQUEST_MAX_SIZE  | 100000000 | How big a request may be (bytes)  |
+    | REQUEST_TIMEOUT   | 60        | How long a request can take (sec) |
+    | KEEP_ALIVE        | True      | Disables keep-alive when False    |

docs/sanic/contributing.md

@@ -4,10 +4,39 @@ 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.
 
+## Installation
+
+To develop on sanic (and mainly to just run the tests) it is highly recommend to
+install from sources.
+
+So assume you have already cloned the repo and are in the working directory with
+a virtual environment already set up, then run:
+
+```bash
+python setup.py develop && pip install -r requirements-dev.txt
+```
+
 ## Running tests
 
-* `python -m pip install pytest`
-* `python -m pytest tests`
+To run the tests for sanic it is recommended to use tox like so:
+
+```bash
+tox
+```
+
+See it's that simple!
+
+## Pull requests!
+
+So the pull request approval rules are pretty simple:
+1. All pull requests must pass unit tests
+* All pull requests must be reviewed and approved by at least 
+one current collaborator on the project
+* All pull requests must pass flake8 checks
+* If you decide to remove/change anything from any common interface
+a deprecation message should accompany it.
+* If you implement a new feature you should have at least one unit
+test to accompany it.
 
 ## Documentation
 

docs/sanic/cookies.md

@@ -5,7 +5,7 @@ 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.
+A user's cookies can be accessed via the `Request` object's `cookies` dictionary.
 
 ```python
 from sanic.response import text
@@ -42,20 +42,20 @@ 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
 ```
 

docs/sanic/decorators.md

@@ -0,0 +1,39 @@
+# Handler Decorators
+
+Since Sanic handlers are simple Python functions, you can apply decorators to them in a similar manner to Flask. A typical use case is when you want some code to run before a handler's code is executed. 
+
+## Authorization Decorator
+
+Let's say you want to check that a user is authorized to access a particular endpoint. You can create a decorator that wraps a handler function, checks a request if the client is authorized to access a resource, and sends the appropriate response.
+
+
+```python
+from functools import wraps
+from sanic.response import json
+
+def authorized():
+    def decorator(f):
+        @wraps(f)
+        async def decorated_function(request, *args, **kwargs):
+            # run some method that checks the request
+            # for the client's authorization status
+            is_authorized = check_request_for_authorization_status(request)
+
+            if is_authorized:
+                # the user is authorized.
+                # run the handler method and return the response
+                response = await f(request, *args, **kwargs)
+                return response
+            else:
+                # the user is not authorized. 
+                return json({'status': 'not_authorized'}, 403)
+        return decorated_function
+    return decorator
+
+
+@app.route("/")
+@authorized()
+async def test(request):
+    return json({status: 'authorized'})
+``` 
+

docs/sanic/deploying.md

@@ -7,15 +7,6 @@ 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).
-- `before_start` *(default `None`)*: Function or list of functions to be executed
-                           before the server starts accepting connections.
-- `after_start` *(default `None`)*: Function or list of functions to be executed
-                    after the server starts accepting connections.
-- `before_stop` *(default `None`)*: Function or list of functions to be
-                    executed when a stop signal is received before it is
-                    respected.
-- `after_stop` *(default `None`)*: Function or list of functions to be executed
-                    when all requests are complete.
 - `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.
@@ -53,3 +44,29 @@ directly run by the interpreter.
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=1337, workers=4)
 ```
+
+## Running via Gunicorn
+
+[Gunicorn](http://gunicorn.org/) ‘Green Unicorn’ is a WSGI HTTP Server for UNIX.
+It’s a pre-fork worker model ported from Ruby’s Unicorn project.
+
+In order to run Sanic application with Gunicorn, you need to use the special `sanic.worker.GunicornWorker`
+for Gunicorn `worker-class` argument:
+
+```
+gunicorn --bind 0.0.0.0:1337 --worker-class sanic.worker.GunicornWorker
+```
+
+## Asynchronous support
+This is suitable if you *need* to share the sanic process with other applications, in particular the `loop`.
+However be advised that this method does not support using multiple processes, and is not the preferred way
+to run the app in general.
+
+Here is an incomplete example (please see `run_async.py` in examples for something more practical):
+
+```python
+server = app.create_server(host="0.0.0.0", port=8000)
+loop = asyncio.get_event_loop()
+task = asyncio.ensure_future(server)
+loop.run_forever()
+```

docs/sanic/extensions.md

@@ -5,5 +5,20 @@ 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.
+- [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
+- [Limiter](https://github.com/bohea/sanic-limiter): Rate limiting for sanic.
+- [Sanic EnvConfig](https://github.com/jamesstidard/sanic-envconfig): Pull environment variables into your sanic config.
+- [Babel](https://github.com/lixxu/sanic-babel): Adds i18n/l10n support to Sanic applications with the help of the
+`Babel` library
+- [Dispatch](https://github.com/ashleysommer/sanic-dispatcher): A dispatcher inspired by `DispatcherMiddleware` in werkzeug. Can act as a Sanic-to-WSGI adapter.
+- [Sanic-OAuth](https://github.com/Sniedes722/Sanic-OAuth): OAuth Library for connecting to & creating your own token providers.
+- [Sanic-nginx-docker-example](https://github.com/itielshwartz/sanic-nginx-docker-example): Simple and easy to use example of Sanic behined nginx using docker-compose.
+- [sanic-graphql](https://github.com/graphql-python/sanic-graphql): GraphQL integration with Sanic
+- [sanic-prometheus](https://github.com/dkruchinin/sanic-prometheus): Prometheus metrics for Sanic
+- [Sanic-RestPlus](https://github.com/ashleysommer/sanic-restplus): A port of Flask-RestPlus for Sanic. Full-featured REST API with SwaggerUI generation.

docs/sanic/index.rst

@@ -7,8 +7,8 @@ On top of being Flask-like, Sanic supports async request handlers.  This means y
 
 Sanic is developed `on GitHub <https://github.com/channelcat/sanic/>`_. Contributions are welcome!
 
-Sanic aspires to be simple:
--------------------
+Sanic aspires to be simple
+---------------------------
 
 .. code:: python
 

docs/sanic/logging.md

@@ -0,0 +1,128 @@
+# Logging
+
+
+Sanic allows you to do different types of logging (access log, error log) on the requests based on the [python3 logging API](https://docs.python.org/3/howto/logging.html). You should have some basic knowledge on python3 logging if you want do create a new configuration.
+
+### Quck Start
+
+A simple example using default setting would be like this:
+
+```python
+from sanic import Sanic
+from sanic.config import LOGGING
+
+# The default logging handlers are ['accessStream', 'errorStream']
+# but we change it to use other handlers here for demo purpose
+LOGGING['loggers']['network']['handlers'] = [
+    'accessTimedRotatingFile', 'errorTimedRotationgFile']
+
+app = Sanic('test')
+
+@app.route('/')
+async def test(request):
+    return response.text('Hello World!')
+
+if __name__ == "__main__":
+  app.run(log_config=LOGGING)
+```
+
+After the program starts, it will log down all the information/requests in access.log and error.log in your working directory.
+
+And to close logging, simply assign log_config=None:
+
+```python
+if __name__ == "__main__":
+  app.run(log_config=None)
+```
+
+This would skip calling logging functions when handling requests.
+And you could even do further in production to gain extra speed:
+
+```python
+if __name__ == "__main__":
+  # disable internal messages
+  app.run(debug=False, log_config=None)
+```
+
+### Configuration
+
+By default, log_config parameter is set to use sanic.config.LOGGING dictionary for configuration. The default configuration provides several predefined `handlers`:
+
+- internal (using [logging.StreamHandler](https://docs.python.org/3/library/logging.handlers.html#logging.StreamHandler))<br>
+  For internal information console outputs.
+
+
+- accessStream (using [logging.StreamHandler](https://docs.python.org/3/library/logging.handlers.html#logging.StreamHandler))<br>
+  For requests information logging in console
+
+
+- errorStream (using [logging.StreamHandler](https://docs.python.org/3/library/logging.handlers.html#logging.StreamHandler))<br>
+  For error message and traceback logging in console.
+
+
+- accessSysLog (using [logging.handlers.SysLogHandler](https://docs.python.org/3/library/logging.handlers.html#logging.handlers.SysLogHandler))<br>
+  For requests information logging to syslog.
+  Currently supports Windows (via localhost:514), Darwin (/var/run/syslog),
+  Linux (/dev/log) and FreeBSD (/dev/log).<br>
+  You would not be able to access this property if the directory doesn't exist.
+  (Notice that in Docker you have to enable everything by yourself)
+
+
+- errorSysLog (using [logging.handlers.SysLogHandler](https://docs.python.org/3/library/logging.handlers.html#logging.handlers.SysLogHandler))<br>
+  For error message and traceback logging to syslog.
+  Currently supports Windows (via localhost:514), Darwin (/var/run/syslog),
+  Linux (/dev/log) and FreeBSD (/dev/log).<br>
+  You would not be able to access this property if the directory doesn't exist.
+  (Notice that in Docker you have to enable everything by yourself)
+
+
+- accessTimedRotatingFile (using [logging.handlers.TimedRotatingFileHandler](https://docs.python.org/3/library/logging.handlers.html#logging.handlers.TimedRotatingFileHandler))<br>
+  For requests information logging to file with daily rotation support.
+
+
+- errorTimedRotatingFile (using [logging.handlers.TimedRotatingFileHandler](https://docs.python.org/3/library/logging.handlers.html#logging.handlers.TimedRotatingFileHandler))<br>
+  For error message and traceback logging to file with daily rotation support.
+
+And `filters`:
+
+- accessFilter (using sanic.defaultFilter.DefaultFilter)<br>
+  The filter that allows only levels in `DEBUG`, `INFO`, and `NONE(0)`
+
+
+- errorFilter (using sanic.defaultFilter.DefaultFilter)<br>
+  The filter taht allows only levels in `WARNING`, `ERROR`, and `CRITICAL`
+
+There are two `loggers` used in sanic, and **must be defined if you want to create your own logging configuration**:
+
+- sanic:<br>
+  Used to log internal messages.
+
+
+- network:<br>
+  Used to log requests from network, and any information from those requests.
+
+#### Log format:
+
+In addition to default parameters provided by python (asctime, levelname, message),
+Sanic provides additional parameters for network logger with accessFilter:
+
+- host (str)<br>
+  request.ip
+
+
+- request (str)<br>
+  request.method + " " + request.url
+
+
+- status (int)<br>
+  response.status
+
+
+- byte (int)<br>
+  len(response.body)
+
+
+The default access log format is 
+```python
+%(asctime)s - (%(name)s)[%(levelname)s][%(host)s]: %(request)s %(message)s %(status)d %(byte)d
+```

docs/sanic/middleware.md

@@ -1,9 +1,13 @@
-# Middleware
+# Middleware And Listeners
 
 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.
 
+Additionally, Sanic providers listeners which allow you to run code at various points of your application's lifecycle.
+
+## Middleware
+
 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
@@ -64,3 +68,45 @@ async def halt_request(request):
 async def halt_response(request, response):
 	return text('I halted the response')
 ```
+
+## Listeners
+
+If you want to execute startup/teardown code as your server starts or closes, you can use the following listeners:
+
+- `before_server_start`
+- `after_server_start`
+- `before_server_stop`
+- `after_server_stop`
+
+These listeners are implemented as decorators on functions which accept the app object as well as the asyncio loop. 
+
+For example:
+
+```python
+@app.listener('before_server_start')
+async def setup_db(app, loop):
+    app.db = await db_setup()
+
+@app.listener('after_server_start')
+async def notify_server_started(app, loop):
+    print('Server successfully started!')
+
+@app.listener('before_server_stop')
+async def notify_server_stopping(app, loop):
+    print('Server shutting down!')
+
+@app.listener('after_server_stop')
+async def close_db(app, loop):
+    await app.db.close()
+```
+
+If you want to schedule a background task to run after the loop has started,
+Sanic provides the `add_task` method to easily do so.
+
+```python
+async def notify_server_started_after_five_seconds():
+    await asyncio.sleep(5)
+    print('Server successfully started!')
+
+app.add_task(notify_server_started_after_five_seconds())
+```

docs/sanic/request_data.md

@@ -9,30 +9,34 @@ The following variables are accessible as properties on `Request` objects:
 
   ```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 `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 })
   ```
 
+- `raw_args` (dict) - On many cases you would need to access the url arguments in
+  a less packed dictionary. For same previous URL `?key1=value1&key2=value2`, the
+  `raw_args` dictionary would look like `{'key1': 'value1', 'key2': 'value2'}`.
+
 - `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')
@@ -50,7 +54,7 @@ The following variables are accessible as properties on `Request` objects:
 
   ```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') })
@@ -58,17 +62,41 @@ The following variables are accessible as properties on `Request` objects:
 
 - `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'})
+
+  ```
+- `url`: The full URL of the request, ie: `http://localhost:8000/posts/1/?foo=bar`
+- `scheme`: The URL scheme associated with the request: `http` or `https`
+- `host`: The host associated with the request: `localhost:8080`
+- `path`: The path of the request: `/posts/1/`
+- `query_string`: The query string of the request: `foo=bar` or a blank string `''`
+- `uri_template`: Template for matching route handler: `/posts/<id>/`
+
+
 ## Accessing values using `get` and `getlist`
 
 The request properties which return a dictionary actually return a subclass of

docs/sanic/response.md

@@ -0,0 +1,102 @@
+# Response
+
+Use functions in `sanic.response` module to create responses.
+
+## Plain Text
+
+```python
+from sanic import response
+
+
+@app.route('/text')
+def handle_request(request):
+    return response.text('Hello world!')
+```
+
+## HTML
+
+```python
+from sanic import response
+
+
+@app.route('/html')
+def handle_request(request):
+    return response.html('<p>Hello world!</p>')
+```
+
+## JSON
+
+
+```python
+from sanic import response
+
+
+@app.route('/json')
+def handle_request(request):
+    return response.json({'message': 'Hello world!'})
+```
+
+## File
+
+```python
+from sanic import response
+
+
+@app.route('/file')
+async def handle_request(request):
+    return await response.file('/srv/www/whatever.png')
+```
+
+## Streaming
+
+```python
+from sanic import response
+
+@app.route("/streaming")
+async def index(request):
+    async def streaming_fn(response):
+        response.write('foo')
+        response.write('bar')
+    return response.stream(streaming_fn, content_type='text/plain')
+```
+
+## Redirect
+
+```python
+from sanic import response
+
+
+@app.route('/redirect')
+def handle_request(request):
+    return response.redirect('/json')
+```
+
+## Raw
+
+Response without encoding the body
+
+```python
+from sanic import response
+
+
+@app.route('/raw')
+def handle_request(request):
+    return response.raw('raw data')
+```
+
+## Modify headers or status
+
+To modify headers or status code, pass the `headers` or `status` argument to those functions:
+
+```python
+from sanic import response
+
+
+@app.route('/json')
+def handle_request(request):
+    return response.json(
+        {'message': 'Hello world!'},
+        headers={'X-Served-By': 'sanic'},
+        status=200
+    )
+```

docs/sanic/routing.md

@@ -11,7 +11,7 @@ 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
@@ -52,7 +52,7 @@ async def integer_handler(request, integer_arg):
 async def number_handler(request, number_arg):
 	return text('Number - {}'.format(number_arg))
 
-@app.route('/person/<name:[A-z]>')
+@app.route('/person/<name:[A-z]+>')
 async def person_handler(request, name):
 	return text('Person - {}'.format(name))
 
@@ -64,9 +64,9 @@ async def folder_handler(request, folder_id):
 
 ## HTTP request types
 
-By default, a route defined on a URL will be avaialble for only GET requests to that URL.
+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`,
-whicl allows the handler function to work with any of the HTTP methods in the list.
+which allows the handler function to work with any of the HTTP methods in the list.
 
 ```python
 from sanic.response import text
@@ -81,6 +81,19 @@ async def get_handler(request):
 
 ```
 
+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
@@ -145,9 +158,60 @@ Other things to keep in mind when using `url_for`:
 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.
 
+## WebSocket routes
 
+Routes for the WebSocket protocol can be defined with the `@app.websocket`
+decorator:
 
+```python
+@app.websocket('/feed')
+async def feed(request, ws):
+    while True:
+        data = 'hello!'
+        print('Sending: ' + data)
+        await ws.send(data)
+        data = await ws.recv()
+        print('Received: ' + data)
+```
 
+Alternatively, the `app.add_websocket_route` method can be used instead of the
+decorator:
+
+```python
+async def feed(request, ws):
+    pass
+
+app.add_websocket_route(my_websocket_handler, '/feed')
+```
+
+Handlers for a WebSocket route are passed the request as first argument, and a
+WebSocket protocol object as second argument. The protocol object has `send`
+and `recv` methods to send and receive data respectively.
+
+WebSocket support requires the [websockets](https://github.com/aaugustin/websockets)
+package by Aymeric Augustin.
 

docs/sanic/ssl.rst

@@ -9,4 +9,12 @@ Optionally pass in an SSLContext:
   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)
+  app.run(host="0.0.0.0", port=8443, ssl=context)
+
+You can also pass in the locations of a certificate and key as a dictionary:
+
+
+.. code:: python
+
+  ssl = {'cert': "/path/to/cert", 'key': "/path/to/keyfile"}
+  app.run(host="0.0.0.0", port=8443, ssl=ssl)

docs/sanic/streaming.md

@@ -0,0 +1,32 @@
+# Streaming
+
+Sanic allows you to stream content to the client with the `stream` method. This method accepts a coroutine callback which is passed a `StreamingHTTPResponse` object that is written to. A simple example is like follows:
+
+```python
+from sanic import Sanic
+from sanic.response import stream
+
+app = Sanic(__name__)
+
+@app.route("/")
+async def test(request):
+    async def sample_streaming_fn(response):
+        response.write('foo,')
+        response.write('bar')
+
+    return stream(sample_streaming_fn, content_type='text/csv')
+```
+
+This is useful in situations where you want to stream content to the client that originates in an external service, like a database. For example, you can stream database records to the client with the asynchronous cursor that `asyncpg` provides:
+
+```python
+@app.route("/")
+async def index(request):
+    async def stream_from_db(response):
+        conn = await asyncpg.connect(database='test')
+        async with conn.transaction():
+            async for record in conn.cursor('SELECT generate_series(0, 10)'):
+                response.write(record[0])
+
+    return stream(stream_from_db)
+```

docs/sanic/testing.md

@@ -1,51 +1,59 @@
 # Testing
 
-Sanic endpoints can be tested locally using the `sanic.utils` module, which
+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 `sanic_endpoint_test` function runs a local server, issues a
-configurable request to an endpoint, and returns the result. It takes the
-following arguments:
+library. 
 
-- `app` An instance of a Sanic app.
-- `method` *(default `'get'`)* A string representing the HTTP method to use.
-- `uri` *(default `'/'`)* A string representing the endpoint to test.
+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.
-- `loop` *(default `None`)* The event loop to use.
-- `debug` *(default `False`)* A boolean which determines whether to run the
-  server in debug mode.
+- `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 with a GET request, `method` would be `get` and the keyword
-argument `params={'value', 'key'}` would be supplied. 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).
+The function further takes the `*request_args` and `**request_kwargs`, which are passed directly to the aiohttp ClientSession request.
 
-Below is a complete example of an endpoint test,
-using [pytest](http://doc.pytest.org/en/latest/). The test checks that the
-`/challenge` endpoint responds to a GET request with a supplied challenge
-string.
+For example, to supply data to a GET request, you would do the following:
 
 ```python
-import pytest
-import aiohttp
-from sanic.utils import sanic_endpoint_test
-
-# Import the Sanic app, usually created with Sanic(__name__)
-from external_server import app
-
-def test_endpoint_challenge():
-    # Create the challenge data
-    request_data = {'challenge': 'dummy_challenge'}
-
-    # Send the request to the endpoint, using the default `get` method
-    request, response = sanic_endpoint_test(app,
-                                            uri='/challenge',
-                                            params=request_data)
-
-    # Assert that the server responds with the challenge string
-    assert response.text == request_data['challenge']
+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).

environment.yml

@@ -15,4 +15,5 @@ dependencies:
   - httptools>=0.0.9
   - ujson>=1.35
   - aiofiles>=0.3.0
+  - websockets>=3.2
   - https://github.com/channelcat/docutils-fork/zipball/master

examples/aiohttp_example.py

@@ -1,5 +1,5 @@
 from sanic import Sanic
-from sanic.response import json
+from sanic import response
 
 import aiohttp
 
@@ -9,20 +9,18 @@ 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()
+    async with session.get(url) as result:
+        return await result.json()
 
 
-@app.route("/")
-async def test(request):
-    """
-    Download and serve example JSON
-    """
+@app.route('/')
+async def handle_request(request):
     url = "https://api.github.com/repos/channelcat/sanic"
-
+    
     async with aiohttp.ClientSession() as session:
-        response = await fetch(session, url)
-        return json(response)
+        result = await fetch(session, url)
+        return response.json(result)
 
 
-app.run(host="0.0.0.0", port=8000, workers=2)
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000, workers=2)

examples/asyncorm/__main__.py

@@ -0,0 +1,140 @@
+from sanic import Sanic
+from sanic.exceptions import NotFound
+from sanic.response import json
+from sanic.views import HTTPMethodView
+
+from asyncorm import configure_orm
+from asyncorm.exceptions import QuerysetError
+
+from library.models import Book
+from library.serializer import BookSerializer
+
+app = Sanic(name=__name__)
+
+
+@app.listener('before_server_start')
+def orm_configure(sanic, loop):
+    db_config = {'database': 'sanic_example',
+                 'host': 'localhost',
+                 'user': 'sanicdbuser',
+                 'password': 'sanicDbPass',
+                 }
+
+    # configure_orm needs a dictionary with:
+    #    * the database configuration
+    #    * the application/s where the models are defined
+    orm_app = configure_orm({'loop': loop,  # always use the sanic loop!
+                             'db_config': db_config,
+                             'modules': ['library', ],  # list of apps
+                             })
+
+    # orm_app is the object that orchestrates the whole ORM
+    # sync_db should be run only once, better do that as external command
+    # it creates the tables in the database!!!!
+    # orm_app.sync_db()
+
+
+# for all the 404 lets handle the exceptions
+@app.exception(NotFound)
+def ignore_404s(request, exception):
+    return json({'method': request.method,
+                 'status': exception.status_code,
+                 'error': exception.args[0],
+                 'results': None,
+                 })
+
+
+# now the propper sanic workflow
+class BooksView(HTTPMethodView):
+    def arg_parser(self, request):
+        parsed_args = {}
+        for k, v in request.args.items():
+            parsed_args[k] = v[0]
+        return parsed_args
+
+    async def get(self, request):
+        filtered_by = self.arg_parser(request)
+
+        if filtered_by:
+            q_books = await Book.objects.filter(**filtered_by)
+        else:
+            q_books = await Book.objects.all()
+
+        books = [BookSerializer.serialize(book) for book in q_books]
+
+        return json({'method': request.method,
+                     'status': 200,
+                     'results': books or None,
+                     'count': len(books),
+                     })
+
+    async def post(self, request):
+        # populate the book with the data in the request
+        book = Book(**request.json)
+
+        # and await on save
+        await book.save()
+
+        return json({'method': request.method,
+                     'status': 201,
+                     'results': BookSerializer.serialize(book),
+                     })
+
+
+class BookView(HTTPMethodView):
+    async def get_object(self, request, book_id):
+        try:
+            # await on database consults
+            book = await Book.objects.get(**{'id': book_id})
+        except QuerysetError as e:
+            raise NotFound(e.args[0])
+        return book
+
+    async def get(self, request, book_id):
+        # await on database consults
+        book = await self.get_object(request, book_id)
+
+        return json({'method': request.method,
+                     'status': 200,
+                     'results': BookSerializer.serialize(book),
+                     })
+
+    async def put(self, request, book_id):
+        # await on database consults
+        book = await self.get_object(request, book_id)
+        # await on save
+        await book.save(**request.json)
+
+        return json({'method': request.method,
+                     'status': 200,
+                     'results': BookSerializer.serialize(book),
+                     })
+
+    async def patch(self, request, book_id):
+        # await on database consults
+        book = await self.get_object(request, book_id)
+        # await on save
+        await book.save(**request.json)
+
+        return json({'method': request.method,
+                     'status': 200,
+                     'results': BookSerializer.serialize(book),
+                     })
+
+    async def delete(self, request, book_id):
+        # await on database consults
+        book = await self.get_object(request, book_id)
+        # await on its deletion
+        await book.delete()
+
+        return json({'method': request.method,
+                     'status': 200,
+                     'results': None
+                     })
+
+
+app.add_route(BooksView.as_view(), '/books/')
+app.add_route(BookView.as_view(), '/books/<book_id:int>/')
+
+if __name__ == '__main__':
+    app.run()

examples/asyncorm/library/models.py

@@ -0,0 +1,21 @@
+from asyncorm.model import Model
+from asyncorm.fields import CharField, IntegerField, DateField
+
+
+BOOK_CHOICES = (
+    ('hard cover', 'hard cover book'),
+    ('paperback', 'paperback book')
+)
+
+
+# This is a simple model definition
+class Book(Model):
+    name = CharField(max_length=50)
+    synopsis = CharField(max_length=255)
+    book_type = CharField(max_length=15, null=True, choices=BOOK_CHOICES)
+    pages = IntegerField(null=True)
+    date_created = DateField(auto_now=True)
+
+    class Meta():
+        ordering = ['name', ]
+        unique_together = ['name', 'synopsis']

examples/asyncorm/library/serializer.py

@@ -0,0 +1,15 @@
+from asyncorm.model import ModelSerializer, SerializerMethod
+from library.models import Book
+
+
+class BookSerializer(ModelSerializer):
+    book_type = SerializerMethod()
+
+    def get_book_type(self, instance):
+        return instance.book_type_display()
+
+    class Meta():
+        model = Book
+        fields = [
+            'id', 'name', 'synopsis', 'book_type', 'pages', 'date_created'
+        ]

examples/asyncorm/requirements.txt

@@ -0,0 +1,2 @@
+asyncorm==0.0.7
+sanic==0.4.1

examples/blueprints.py

@@ -6,6 +6,7 @@ from sanic.response import json, text
 app = Sanic(__name__)
 blueprint = Blueprint('name', url_prefix='/my_blueprint')
 blueprint2 = Blueprint('name', url_prefix='/my_blueprint2')
+blueprint3 = Blueprint('name', url_prefix='/my_blueprint3')
 
 
 @blueprint.route('/foo')
@@ -17,8 +18,17 @@ async def foo(request):
 async def foo2(request):
     return json({'msg': 'hi from blueprint2'})
 
+@blueprint3.websocket('/foo')
+async def foo3(request, ws):
+    while True:
+        data = 'hello!'
+        print('Sending: ' + data)
+        await ws.send(data)
+        data = await ws.recv()
+        print('Received: ' + data)
 
-app.register_blueprint(blueprint)
-app.register_blueprint(blueprint2)
+app.blueprint(blueprint)
+app.blueprint(blueprint2)
+app.blueprint(blueprint3)
 
 app.run(host="0.0.0.0", port=8000, debug=True)

examples/cache_example.py

@@ -1,6 +1,6 @@
 """
 Example of caching using aiocache package. To run it you will need a Redis
-instance running in localhost:6379.
+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.
@@ -20,9 +20,14 @@ from aiocache.serializers import JsonSerializer
 
 app = Sanic(__name__)
 
-aiocache.settings.set_defaults(
-    class_="aiocache.RedisCache"
-)
+
+@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())
@@ -38,4 +43,4 @@ async def test(request):
     return json(await expensive_call())
 
 
-app.run(host="0.0.0.0", port=8000, loop=asyncio.get_event_loop())
+app.run(host="0.0.0.0", port=8000)

examples/dask_distributed.py

@@ -0,0 +1,41 @@
+from sanic import Sanic
+from sanic import response
+
+from tornado.platform.asyncio import BaseAsyncIOLoop, to_asyncio_future
+from distributed import LocalCluster, Client
+
+
+app = Sanic(__name__)
+
+
+def square(x):
+    return x**2
+
+
+@app.listener('after_server_start')
+async def setup(app, loop):
+    # configure tornado use asyncio's loop
+    ioloop = BaseAsyncIOLoop(loop)
+
+    # init distributed client
+    app.client = Client('tcp://localhost:8786', loop=ioloop, start=False)
+    await to_asyncio_future(app.client._start())
+
+
+@app.listener('before_server_stop')
+async def stop(app, loop):
+    await to_asyncio_future(app.client._shutdown())
+
+
+@app.route('/<value:int>')
+async def test(request, value):
+    future = app.client.submit(square, value)
+    result = await to_asyncio_future(future._result())
+    return response.text(f'The square of {value} is {result}')
+
+
+if __name__ == '__main__':
+    # Distributed cluster should run somewhere else
+    with LocalCluster(scheduler_port=8786, nanny=False, n_workers=2,
+                      threads_per_worker=1) as cluster:
+        app.run(host="0.0.0.0", port=8000)

examples/detailed_example.py

@@ -0,0 +1,136 @@
+# This demo requires aioredis and environmental variables established in ENV_VARS
+import json
+import logging
+import os
+
+from datetime import datetime
+
+import aioredis
+
+import sanic
+from sanic import Sanic
+
+
+ENV_VARS = ["REDIS_HOST", "REDIS_PORT",
+            "REDIS_MINPOOL", "REDIS_MAXPOOL",
+            "REDIS_PASS", "APP_LOGFILE"]
+
+app = Sanic(name=__name__)
+
+logger = None
+
+
+@app.middleware("request")
+async def log_uri(request):
+    # Simple middleware to log the URI endpoint that was called
+    logger.info("URI called: {0}".format(request.url))
+
+
+@app.listener('before_server_start')
+async def before_server_start(app, loop):
+    logger.info("Starting redis pool")
+    app.redis_pool = await aioredis.create_pool(
+        (app.config.REDIS_HOST, int(app.config.REDIS_PORT)),
+        minsize=int(app.config.REDIS_MINPOOL),
+        maxsize=int(app.config.REDIS_MAXPOOL),
+        password=app.config.REDIS_PASS)
+
+
+@app.listener('after_server_stop')
+async def after_server_stop(app, loop):
+    logger.info("Closing redis pool")
+    app.redis_pool.close()
+    await app.redis_pool.wait_closed()
+
+
+@app.middleware("request")
+async def attach_db_connectors(request):
+    # Just put the db objects in the request for easier access
+    logger.info("Passing redis pool to request object")
+    request["redis"] = request.app.redis_pool
+
+
+@app.route("/state/<user_id>", methods=["GET"])
+async def access_state(request, user_id):
+    try:
+        # Check to see if the value is in cache, if so lets return that
+        with await request["redis"] as redis_conn:
+            state = await redis_conn.get(user_id, encoding="utf-8")
+            if state:
+                return sanic.response.json({"msg": "Success",
+                                            "status": 200,
+                                            "success": True,
+                                            "data": json.loads(state),
+                                            "finished_at": datetime.now().isoformat()})
+        # Then state object is not in redis
+        logger.critical("Unable to find user_data in cache.")
+        return sanic.response.HTTPResponse({"msg": "User state not found",
+                                            "success": False,
+                                            "status": 404,
+                                            "finished_at": datetime.now().isoformat()}, status=404)
+    except aioredis.ProtocolError:
+        logger.critical("Unable to connect to state cache")
+        return sanic.response.HTTPResponse({"msg": "Internal Server Error",
+                                            "status": 500,
+                                            "success": False,
+                                            "finished_at": datetime.now().isoformat()}, status=500)
+
+
+@app.route("/state/<user_id>/push", methods=["POST"])
+async def set_state(request, user_id):
+    try:
+        # Pull a connection from the pool
+        with await request["redis"] as redis_conn:
+            # Set the value in cache to your new value
+            await redis_conn.set(user_id, json.dumps(request.json), expire=1800)
+            logger.info("Successfully pushed state to cache")
+            return sanic.response.HTTPResponse({"msg": "Successfully pushed state to cache",
+                                                "success": True,
+                                                "status": 200,
+                                                "finished_at": datetime.now().isoformat()})
+    except aioredis.ProtocolError:
+        logger.critical("Unable to connect to state cache")
+        return sanic.response.HTTPResponse({"msg": "Internal Server Error",
+                                            "status": 500,
+                                            "success": False,
+                                            "finished_at": datetime.now().isoformat()}, status=500)
+
+
+def configure():
+    # Setup environment variables
+    env_vars = [os.environ.get(v, None) for v in ENV_VARS]
+    if not all(env_vars):
+        # Send back environment variables that were not set
+        return False, ", ".join([ENV_VARS[i] for i, flag in env_vars if not flag])
+    else:
+        # Add all the env vars to our app config
+        app.config.update({k: v for k, v in zip(ENV_VARS, env_vars)})
+        setup_logging()
+    return True, None
+
+
+def setup_logging():
+    logging_format = "[%(asctime)s] %(process)d-%(levelname)s "
+    logging_format += "%(module)s::%(funcName)s():l%(lineno)d: "
+    logging_format += "%(message)s"
+
+    logging.basicConfig(
+        filename=app.config.APP_LOGFILE,
+        format=logging_format,
+        level=logging.DEBUG)
+
+
+def main(result, missing):
+    if result:
+        try:
+            app.run(host="0.0.0.0", port=8080, debug=True)
+        except:
+            logging.critical("User killed server. Closing")
+    else:
+        logging.critical("Unable to start. Missing environment variables [{0}]".format(missing))
+
+
+if __name__ == "__main__":
+    result, missing = configure()
+    logger = logging.getLogger()
+    main(result, missing)

examples/exception_monitoring.py

@@ -1,22 +1,21 @@
 """
 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
+from sanic.handlers import ErrorHandler
+from sanic.exceptions import SanicException
 """
 Imports and code relevant for our CustomHandler class
 (Ordinarily this would be in a separate file)
 """
 
 
-class CustomHandler(Handler):
+class CustomHandler(ErrorHandler):
 
     def default(self, request, exception):
         # Here, we have access to the exception object
@@ -38,11 +37,11 @@ server's error_handler to an instance of our CustomHandler
 """
 
 from sanic import Sanic
-from sanic.response import json
+from sanic import response
 
 app = Sanic(__name__)
 
-handler = CustomHandler(sanic=app)
+handler = CustomHandler()
 app.error_handler = handler
 
 
@@ -51,7 +50,7 @@ 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})
+    return response.json({"test": True})
 
 
-app.run(host="0.0.0.0", port=8000, debug=True)
+app.run(host="0.0.0.0", port=8000, debug=True)

examples/jinja_example.py

@@ -1,18 +0,0 @@
-## 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/jinja_example/jinja_example.py

@@ -0,0 +1,28 @@
+# Render templates in a Flask like way from a "template" directory in
+# the project
+
+from sanic import Sanic
+from sanic import response
+from jinja2 import Environment, PackageLoader, select_autoescape
+
+app = Sanic(__name__)
+
+# Load the template environment with async support
+template_env = Environment(
+    loader=PackageLoader('jinja_example', 'templates'),
+    autoescape=select_autoescape(['html', 'xml']),
+    enable_async=True
+)
+
+# Load the template from file
+template = template_env.get_template("example_template.html")
+
+
+@app.route('/')
+async def test(request):
+    rendered_template = await template.render_async(
+        knights='that say nih; asynchronously')
+    return response.html(rendered_template)
+
+
+app.run(host="0.0.0.0", port=8080, debug=True)

examples/jinja_example/requirements.txt

@@ -0,0 +1,8 @@
+aiofiles==0.3.1
+httptools==0.0.9
+Jinja2==2.9.6
+MarkupSafe==1.0
+sanic==0.5.2
+ujson==1.35
+uvloop==0.8.0
+websockets==3.3

examples/jinja_example/templates/example_template.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>My Webpage</title>
+</head>
+<body>
+    <h1>Hello World</h1>
+    <p>knights - {{ knights }}</p>
+</body>
+</html>

examples/limit_concurrency.py

@@ -8,6 +8,7 @@ app = Sanic(__name__)
 
 sem = None
 
+@app.listener('before_server_start')
 def init(sanic, loop):
     global sem
     CONCURRENCY_PER_WORKER = 4
@@ -33,4 +34,4 @@ async def test(request):
         return json(response)
 
 
-app.run(host="0.0.0.0", port=8000, workers=2, before_start=init)
+app.run(host="0.0.0.0", port=8000, workers=2)

examples/modify_header_example.py

@@ -0,0 +1,26 @@
+"""
+Modify header or status in response
+"""
+
+from sanic import Sanic
+from sanic import response
+
+app = Sanic(__name__)
+
+@app.route('/')
+def handle_request(request):
+    return response.json(
+        {'message': 'Hello world!'},
+        headers={'X-Served-By': 'sanic'},
+        status=200
+    )
+    
+@app.route('/unauthorized')
+def handle_request(request):
+    return response.json(
+        {'message': 'You are not authorized'},
+        headers={'X-Served-By': 'sanic'},
+        status=404
+    )
+
+app.run(host="0.0.0.0", port=8000, debug=True)

examples/override_logging.py

@@ -1,6 +1,5 @@
 from sanic import Sanic
-from sanic.response import text
-import json
+from sanic import response
 import logging
 
 logging_format = "[%(asctime)s] %(process)d-%(levelname)s "
@@ -18,6 +17,6 @@ sanic = Sanic()
 @sanic.route("/")
 def test(request):
     log.info("received request; responding with 'hey'")
-    return text("hey")
+    return response.text("hey")
 
 sanic.run(host="0.0.0.0", port=8000)

examples/plotly_example/plotlyjs_example.py

@@ -0,0 +1,85 @@
+from sanic import Sanic
+
+from sanic_session import InMemorySessionInterface
+from sanic_jinja2 import SanicJinja2
+
+import json
+import plotly
+
+import pandas as pd
+import numpy as np
+
+app = Sanic(__name__)
+
+jinja = SanicJinja2(app)
+session = InMemorySessionInterface(cookie_name=app.name, prefix=app.name)
+
+@app.middleware('request')
+async def print_on_request(request):
+	print(request.headers)
+	await session.open(request)
+
+@app.middleware('response')
+async def print_on_response(request, response):
+	await session.save(request, response)
+
+
+
+@app.route('/')
+async def index(request):
+    rng = pd.date_range('1/1/2011', periods=7500, freq='H')
+    ts = pd.Series(np.random.randn(len(rng)), index=rng)
+
+    graphs = [
+        dict(
+            data=[
+                dict(
+                    x=[1, 2, 3],
+                    y=[10, 20, 30],
+                    type='scatter'
+                ),
+            ],
+            layout=dict(
+                title='first graph'
+            )
+        ),
+
+        dict(
+            data=[
+                dict(
+                    x=[1, 3, 5],
+                    y=[10, 50, 30],
+                    type='bar'
+                ),
+            ],
+            layout=dict(
+                title='second graph'
+            )
+        ),
+
+        dict(
+            data=[
+                dict(
+                    x=ts.index,  # Can use the pandas data structures directly
+                    y=ts
+                )
+            ]
+        )
+    ]
+
+    # Add "ids" to each of the graphs to pass up to the client
+    # for templating
+    ids = ['graph-{}'.format(i) for i, _ in enumerate(graphs)]
+
+    # Convert the figures to JSON
+    # PlotlyJSONEncoder appropriately converts pandas, datetime, etc
+    # objects to their JSON equivalents
+    graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)
+
+    return jinja.render('index.html', request,
+                           ids=ids,
+                           graphJSON=graphJSON)
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000, debug=True)

examples/plotly_example/requirements.txt

@@ -0,0 +1,5 @@
+pandas==0.19.2
+plotly==2.0.7
+sanic==0.5.0
+sanic-jinja2==0.5.1
+sanic-session==0.1.3

examples/redirect_example.py

@@ -0,0 +1,17 @@
+from sanic import Sanic
+from sanic import response
+
+app = Sanic(__name__)
+
+    
+@app.route('/')
+def handle_request(request):
+    return response.redirect('/redirect')
+    
+@app.route('/redirect')
+async def test(request):
+    return response.json({"Redirected": True})
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000)

examples/request_timeout.py

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

examples/run_async.py

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

examples/sanic_aiomysql_with_global_pool.py

@@ -0,0 +1,62 @@
+# encoding: utf-8
+"""
+You need the aiomysql
+"""
+import os
+
+import aiomysql
+
+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']
+app = Sanic()
+
+
+@app.listener("before_server_start")
+async def get_pool(app, loop):
+    """
+    the first param  is the global instance ,
+    so we can store our connection pool in it .
+    and it can be used by different request
+    :param args:
+    :param kwargs:
+    :return:
+    """
+    app.pool = {
+        "aiomysql": await aiomysql.create_pool(host=database_host, user=database_user, password=database_password,
+                                               db=database_name,
+                                               maxsize=5)}
+    async with app.pool['aiomysql'].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 test():
+    result = []
+    data = {}
+    async with app.pool['aiomysql'].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]})
+    if result or len(result) > 0:
+        data['data'] = res
+    return json(data)
+
+
+if __name__ == '__main__':
+    app.run(host="127.0.0.1", workers=4, port=12000)

examples/sanic_aiopeewee.py

@@ -0,0 +1,61 @@
+from sanic import Sanic
+from sanic.response import json
+
+from aiopeewee import AioModel, AioMySQLDatabase, model_to_dict
+from peewee import CharField, TextField, DateTimeField
+from peewee import ForeignKeyField, PrimaryKeyField
+
+
+db = AioMySQLDatabase('test', user='root', password='',
+                      host='127.0.0.1', port=3306)
+
+
+class User(AioModel):
+    username = CharField()
+
+    class Meta:
+        database = db
+
+
+class Blog(AioModel):
+    user = ForeignKeyField(User)
+    title = CharField(max_length=25)
+    content = TextField(default='')
+    pub_date = DateTimeField(null=True)
+    pk = PrimaryKeyField()
+
+    class Meta:
+        database = db
+
+
+app = Sanic(__name__)
+
+
+@app.listener('before_server_start')
+async def setup(app, loop):
+    # create connection pool
+    await db.connect(loop)
+    # create table if not exists
+    await db.create_tables([User, Blog], safe=True)
+
+
+@app.listener('before_server_stop')
+async def stop(app, loop):
+    # close connection pool
+    await db.close()
+
+
+@app.post('/users')
+async def add_user(request):
+    user = await User.create(**request.json)
+    return json(await model_to_dict(user))
+
+
+@app.get('/users/count')
+async def user_count(request):
+    count = await User.select().count()
+    return json({'count': count})
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000)

examples/sanic_aiopg_example.py

@@ -26,6 +26,7 @@ async def get_pool():
 
 app = Sanic(name=__name__)
 
+@app.listener('before_server_start')
 async def prepare_db(app, loop):
     """
     Let's create some table and add some data
@@ -61,5 +62,4 @@ async def handle(request):
 if __name__ == '__main__':
     app.run(host='0.0.0.0',
             port=8000,
-            debug=True,
-            before_start=prepare_db)
+            debug=True)

examples/sanic_aiopg_sqlalchemy_example.py

@@ -32,7 +32,7 @@ polls = sa.Table('sanic_polls', metadata,
 
 app = Sanic(name=__name__)
 
-
+@app.listener('before_server_start')
 async def prepare_db(app, loop):
     """ Let's add some data
 
@@ -58,9 +58,10 @@ async def handle(request):
         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})
+                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, before_start=prepare_db)
+    app.run(host='0.0.0.0', port=8000)

examples/sanic_aioredis_example.py

@@ -0,0 +1,34 @@
+""" To run this example you need additional aioredis package
+"""
+from sanic import Sanic, response
+import aioredis
+
+app = Sanic(__name__)
+
+
+@app.route("/")
+async def handle(request):
+    async with request.app.redis_pool.get() as redis:
+        await redis.set('test-my-key', 'value')
+        val = await redis.get('test-my-key')
+    return response.text(val.decode('utf-8'))
+
+
+@app.listener('before_server_start')
+async def before_server_start(app, loop):
+    app.redis_pool = await aioredis.create_pool(
+        ('localhost', 6379),
+        minsize=5,
+        maxsize=10,
+        loop=loop
+    )
+
+
+@app.listener('after_server_stop')
+async def after_server_stop(app, loop):
+    app.redis_pool.close()
+    await app.redis_pool.wait_closed()
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000)

examples/sanic_asyncpg_example.py

@@ -1,58 +1,51 @@
-""" To run this example you need additional asyncpg package
-
-"""
 import os
 import asyncio
 
 import uvloop
-from asyncpg import create_pool
+from asyncpg import connect, create_pool
 
 from sanic import Sanic
 from sanic.response import json
 
 DB_CONFIG = {
     'host': '<host>',
-    'user': '<username>',
+    'user': '<user>',
     '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]
+    return [dict(r.items()) for r in records]
+
 
 app = Sanic(__name__)
 
-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.listener('before_server_start')
+async def register_db(app, loop):
+    app.pool = await create_pool(**DB_CONFIG, loop=loop, max_size=100)
+    async with app.pool.acquire() as connection:
+        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, 1000):
+            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)})
-
+@app.get('/')
+async def root_get(request):
+    async with app.pool.acquire() as connection:
+        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, before_start=create_db)
+    app.run(host='127.0.0.1', port=8080)

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 import response
+
+
+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 response.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 response.json({'object_id': str(object_id)})
+
+
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=8000, debug=True)

examples/sanic_peewee.py

@@ -1,3 +1,4 @@
+
 ## You need the following additional packages for this example
 # aiopg
 # peewee_async
@@ -10,50 +11,87 @@ from sanic.response import json
 
 ## peewee_async related imports
 import peewee
-from peewee_async import Manager, PostgresqlDatabase
-
+from peewee import Model, BaseModel
+from peewee_async import Manager, PostgresqlDatabase, execute
+from functools import partial
  # we instantiate a custom loop so we can pass it to our db manager
 
-def setup(app, loop):
-    database = PostgresqlDatabase(database='test',
-                                  host='127.0.0.1',
-                                  user='postgres',
-                                  password='mysecretpassword')
-
-    objects = Manager(database, loop=loop)
-
 ## 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.
 
+class AsyncManager(Manager):
+    """Inherit the peewee_async manager with our own object
+       configuration
+
+       database.allow_sync = False
+    """
+
+    def __init__(self, _model_class, *args, **kwargs):
+        super(AsyncManager, self).__init__(*args, **kwargs)
+        self._model_class = _model_class
+        self.database.allow_sync = False
+
+    def _do_fill(self, method, *args, **kwargs):
+        _class_method = getattr(super(AsyncManager, self), method)
+        pf = partial(_class_method, self._model_class)
+        return pf(*args, **kwargs)
+
+    def new(self, *args, **kwargs):
+        return self._do_fill('create', *args, **kwargs)
+
+    def get(self, *args, **kwargs):
+        return self._do_fill('get', *args, **kwargs)
+
+    def execute(self, query):
+        return execute(query)
+
+
+def _get_meta_db_class(db):
+    """creating a declartive class model for db"""
+    class _BlockedMeta(BaseModel):
+        def __new__(cls, name, bases, attrs):
+            _instance = super(_BlockedMeta, cls).__new__(cls, name, bases, attrs)
+            _instance.objects = AsyncManager(_instance, db)
+            return _instance
+
+    class _Base(Model, metaclass=_BlockedMeta):
+
+        def to_dict(self):
+            return self._data
+
+        class Meta:
+            database=db
+    return _Base
+
+
+def declarative_base(*args, **kwargs):
+    """Returns a new Modeled Class after inheriting meta and Model classes"""
+    db = PostgresqlDatabase(*args, **kwargs)
+    return _get_meta_db_class(db)
+
+
+AsyncBaseModel = declarative_base(database='test',
+                                  host='127.0.0.1',
+                                  user='postgres',
+                                  password='mysecretpassword')
 
 # let's create a simple key value store:
-class KeyValue(peewee.Model):
+class KeyValue(AsyncBaseModel):
     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.route('/post/<key>/<value>')
 async def post(request, key, value):
     """
     Save get parameters to database
     """
-    obj = await objects.create(KeyValue, key=key, text=value)
+    obj = await KeyValue.objects.new(key=key, text=value)
     return json({'object_id': obj.id})
 
 
@@ -62,7 +100,7 @@ async def get(request):
     """
     Load all objects from database
     """
-    all_objects = await objects.execute(KeyValue.select())
+    all_objects = await KeyValue.objects.execute(KeyValue.select())
     serialized_obj = []
     for obj in all_objects:
         serialized_obj.append({
@@ -75,4 +113,4 @@ async def get(request):
 
 
 if __name__ == "__main__":
-    app.run(host='0.0.0.0', port=8000, before_start=setup)
+    app.run(host='0.0.0.0', port=8000)

examples/simple_server.py

@@ -1,12 +1,13 @@
 from sanic import Sanic
-from sanic.response import json
+from sanic import response
 
 app = Sanic(__name__)
 
 
 @app.route("/")
 async def test(request):
-    return json({"test": True})
+    return response.json({"test": True})
 
 
-app.run(host="0.0.0.0", port=8000)
+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 import response
 from sanic.exceptions import ServerError
 
 app = Sanic(__name__)
@@ -8,17 +10,17 @@ app = Sanic(__name__)
 
 @app.route("/")
 async def test_async(request):
-    return json({"test": True})
+    return response.json({"test": True})
 
 
 @app.route("/sync", methods=['GET', 'POST'])
 def test_sync(request):
-    return json({"test": True})
+    return response.json({"test": True})
 
 
 @app.route("/dynamic/<name>/<id:int>")
 def test_params(request, name, id):
-    return text("yeehaww {} {}".format(name, id))
+    return response.text("yeehaww {} {}".format(name, id))
 
 
 @app.route("/exception")
@@ -29,7 +31,11 @@ def exception(request):
 async def test_await(request):
     import asyncio
     await asyncio.sleep(5)
-    return text("I'm feeling sleepy")
+    return response.text("I'm feeling sleepy")
+
+@app.route("/file")
+async def test_file(request):
+    return await response.file(os.path.abspath("setup.py"))
 
 
 # ----------------------------------------------- #
@@ -38,7 +44,7 @@ async def test_await(request):
 
 @app.exception(ServerError)
 async def test(request, exception):
-    return json({"exception": "{}".format(exception), "status": exception.status_code}, status=exception.status_code)
+    return response.json({"exception": "{}".format(exception), "status": exception.status_code}, status=exception.status_code)
 
 
 # ----------------------------------------------- #
@@ -47,29 +53,42 @@ async def test(request, exception):
 
 @app.route("/json")
 def post_json(request):
-    return json({"received": True, "message": request.json})
+    return response.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')})
+    return response.json({"received": True, "form_data": request.form, "test": request.form.get('test')})
 
 
 @app.route("/query_string")
 def query_string(request):
-    return json({"parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string})
+    return response.json({"parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string})
 
 
 # ----------------------------------------------- #
 # Run Server
 # ----------------------------------------------- #
 
+@app.listener('before_server_start')
+def before_start(app, loop):
+    log.info("SERVER STARTING")
+
+
+@app.listener('after_server_start')
 def after_start(app, loop):
     log.info("OH OH OH OH OHHHHHHHH")
 
 
+@app.listener('before_server_stop')
 def before_stop(app, loop):
+    log.info("SERVER STOPPING")
+
+
+@app.listener('after_server_stop')
+def after_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)
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000, debug=True)

examples/url_for_example.py

@@ -0,0 +1,18 @@
+from sanic import Sanic
+from sanic import response
+
+app = Sanic(__name__)
+
+@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 response.redirect(url)
+
+@app.route('/posts/<post_id>')
+async def post_handler(request, post_id):
+    return response.text('Post - {}'.format(post_id))
+    
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000, debug=True)

examples/vhosts.py

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

examples/websocket.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>WebSocket demo</title>
+    </head>
+    <body>
+        <script>
+            var ws = new WebSocket('ws://' + document.domain + ':' + location.port + '/feed'),
+                messages = document.createElement('ul');
+            ws.onmessage = function (event) {
+                var messages = document.getElementsByTagName('ul')[0],
+                    message = document.createElement('li'),
+                    content = document.createTextNode('Received: ' + event.data);
+                message.appendChild(content);
+                messages.appendChild(message);
+            };
+            document.body.appendChild(messages);
+            window.setInterval(function() {
+                data = 'bye!'
+                ws.send(data);
+                var messages = document.getElementsByTagName('ul')[0],
+                    message = document.createElement('li'),
+                    content = document.createTextNode('Sent: ' + data);
+                message.appendChild(content);
+                messages.appendChild(message);
+            }, 1000);
+        </script>
+    </body>
+</html>

examples/websocket.py

@@ -0,0 +1,23 @@
+from sanic import Sanic
+from sanic.response import file
+
+app = Sanic(__name__)
+
+
+@app.route('/')
+async def index(request):
+    return await file('websocket.html')
+
+
+@app.websocket('/feed')
+async def feed(request, ws):
+    while True:
+        data = 'hello!'
+        print('Sending: ' + data)
+        await ws.send(data)
+        data = await ws.recv()
+        print('Received: ' + data)
+
+
+if __name__ == '__main__':
+    app.run()

requirements-dev.txt

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

requirements.txt

@@ -2,3 +2,4 @@ aiofiles
 httptools
 ujson
 uvloop
+websockets

sanic/__init__.py

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

sanic/__main__.py

@@ -1,13 +1,17 @@
 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')
     parser.add_argument('--host', dest='host', type=str, default='127.0.0.1')
     parser.add_argument('--port', dest='port', type=int, default=8000)
+    parser.add_argument('--cert', dest='cert', type=str,
+                        help='location of certificate for SSL')
+    parser.add_argument('--key', dest='key', type=str,
+                        help='location of keyfile for SSL.')
     parser.add_argument('--workers', dest='workers', type=int, default=1, )
     parser.add_argument('--debug', dest='debug', action="store_true")
     parser.add_argument('module')
@@ -24,13 +28,17 @@ if __name__ == "__main__":
             raise ValueError("Module is not a Sanic app, it is a {}.  "
                              "Perhaps you meant {}.app?"
                              .format(type(app).__name__, args.module))
+        if args.cert is not None or args.key is not None:
+            ssl = {'cert': args.cert, 'key': args.key}
+        else:
+            ssl = None
 
         app.run(host=args.host, port=args.port,
-                workers=args.workers, debug=args.debug)
-    except ImportError:
+                workers=args.workers, debug=args.debug, ssl=ssl)
+    except ImportError as e:
         log.error("No module named {} found.\n"
                   "  Example File: project/sanic_server.py -> app\n"
                   "  Example Module: project.sanic_server.app"
-                  .format(module_name))
+                  .format(e.name))
     except ValueError as e:
         log.error("{}".format(e))

sanic/app.py

@@ -0,0 +1,703 @@
+import logging
+import logging.config
+import re
+import warnings
+from asyncio import get_event_loop, ensure_future, CancelledError
+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 ssl import create_default_context, Purpose
+
+from sanic.config import Config, LOGGING
+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, StreamingHTTPResponse
+from sanic.router import Router
+from sanic.server import serve, serve_multiple, HttpProtocol, Signal
+from sanic.static import register as static_register
+from sanic.testing import SanicTestClient
+from sanic.views import CompositionView
+from sanic.websocket import WebSocketProtocol, ConnectionClosed
+
+
+class Sanic:
+
+    def __init__(self, name=None, router=None, error_handler=None,
+                 load_env=True, request_class=None,
+                 log_config=LOGGING):
+        if log_config:
+            logging.config.dictConfig(log_config)
+        # 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.request_class = request_class
+        self.error_handler = error_handler or ErrorHandler()
+        self.config = Config(load_env=load_env)
+        self.log_config = log_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
+        self.websocket_enabled = False
+        self.websocket_tasks = []
+
+        # 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,
+              strict_slashes=False):
+        """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, strict_slashes=strict_slashes)
+            return handler
+
+        return response
+
+    # Shorthand method decorators
+    def get(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"GET"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def post(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"POST"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def put(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"PUT"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def head(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"HEAD"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def options(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"OPTIONS"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def patch(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"PATCH"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def delete(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=frozenset({"DELETE"}), host=host,
+                          strict_slashes=strict_slashes)
+
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None,
+                  strict_slashes=False):
+        """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,
+                   strict_slashes=strict_slashes)(handler)
+        return handler
+
+    # Decorator
+    def websocket(self, uri, host=None, strict_slashes=False):
+        """Decorate a function to be registered as a websocket route
+        :param uri: path of the URL
+        :param host:
+        :return: decorated function
+        """
+        self.enable_websocket()
+
+        # 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):
+            async def websocket_handler(request, *args, **kwargs):
+                request.app = self
+                protocol = request.transport.get_protocol()
+                ws = await protocol.websocket_handshake(request)
+
+                # schedule the application handler
+                # its future is kept in self.websocket_tasks in case it
+                # needs to be cancelled due to the server being stopped
+                fut = ensure_future(handler(request, ws, *args, **kwargs))
+                self.websocket_tasks.append(fut)
+                try:
+                    await fut
+                except (CancelledError, ConnectionClosed):
+                    pass
+                self.websocket_tasks.remove(fut)
+                await ws.close()
+
+            self.router.add(uri=uri, handler=websocket_handler,
+                            methods=frozenset({'GET'}), host=host,
+                            strict_slashes=strict_slashes)
+            return handler
+
+        return response
+
+    def add_websocket_route(self, handler, uri, host=None,
+                            strict_slashes=False):
+        """A helper method to register a function as a websocket route."""
+        return self.websocket(uri, host=host,
+                              strict_slashes=strict_slashes)(handler)
+
+    def enable_websocket(self, enable=True):
+        """Enable or disable the support for websocket.
+
+        Websocket is enabled automatically if websocket routes are
+        added to the application.
+        """
+        if not self.websocket_enabled:
+            # if the server is stopped, we want to cancel any ongoing
+            # websocket tasks, to allow the server to exit promptly
+            @self.listener('before_server_stop')
+            def cancel_websocket_tasks(app, loop):
+                for task in self.websocket_tasks:
+                    task.cancel()
+
+        self.websocket_enabled = enable
+
+    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:
+                if isinstance(exception, (tuple, list)):
+                    for e in exception:
+                        self.error_handler.add(e, handler)
+                else:
+                    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=r'/?.+',
+               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, write_callback, stream_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 write_callback: Synchronous response function to be
+            called with the response as the only argument
+        :param stream_callback: Coroutine that handles streaming a
+            StreamingHTTPResponse if produced by the handler.
+
+        :return: Nothing
+        """
+        try:
+            # -------------------------------------------- #
+            # Request Middleware
+            # -------------------------------------------- #
+
+            request.app = self
+            response = await self._run_request_middleware(request)
+            # No middleware results
+            if not response:
+                # -------------------------------------------- #
+                # Execute Handler
+                # -------------------------------------------- #
+
+                # Fetch handler from router
+                handler, args, kwargs, uri = self.router.get(request)
+                request.uri_template = uri
+                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
+        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")
+        finally:
+            # -------------------------------------------- #
+            # Response Middleware
+            # -------------------------------------------- #
+            try:
+                response = await self._run_response_middleware(request,
+                                                               response)
+            except:
+                log.exception(
+                    'Exception occured in one of response middleware handlers'
+                )
+
+        # pass the response to the correct callback
+        if isinstance(response, StreamingHTTPResponse):
+            await stream_callback(response)
+        else:
+            write_callback(response)
+
+    # -------------------------------------------------------------------- #
+    # Testing
+    # -------------------------------------------------------------------- #
+
+    @property
+    def test_client(self):
+        return SanicTestClient(self)
+
+    # -------------------------------------------------------------------- #
+    # Execution
+    # -------------------------------------------------------------------- #
+
+    def run(self, host="127.0.0.1", port=8000, debug=False, ssl=None,
+            sock=None, workers=1, protocol=None,
+            backlog=100, stop_event=None, register_sys_signals=True,
+            log_config=LOGGING):
+        """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 ssl: SSLContext, or location of certificate and key
+                            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 backlog:
+        :param stop_event:
+        :param register_sys_signals:
+        :param protocol: Subclass of asyncio protocol class
+        :return: Nothing
+        """
+        if log_config:
+            logging.config.dictConfig(log_config)
+        if protocol is None:
+            protocol = (WebSocketProtocol if self.websocket_enabled
+                        else HttpProtocol)
+        if stop_event is not None:
+            if debug:
+                warnings.simplefilter('default')
+            warnings.warn("stop_event will be removed from future versions.",
+                          DeprecationWarning)
+        server_settings = self._helper(
+            host=host, port=port, debug=debug, ssl=ssl, sock=sock,
+            workers=workers, protocol=protocol, backlog=backlog,
+            register_sys_signals=register_sys_signals,
+            has_log=log_config is not None)
+
+        try:
+            self.is_running = True
+            if workers == 1:
+                serve(**server_settings)
+            else:
+                serve_multiple(server_settings, workers)
+        except:
+            log.exception(
+                'Experienced exception while trying to serve')
+            raise
+        finally:
+            self.is_running = False
+        log.info("Server Stopped")
+
+    def stop(self):
+        """This kills the Sanic"""
+        get_event_loop().stop()
+
+    def __call__(self):
+        """gunicorn compatibility"""
+        return self
+
+    async def create_server(self, host="127.0.0.1", port=8000, debug=False,
+                            ssl=None, sock=None, protocol=None,
+                            backlog=100, stop_event=None,
+                            log_config=LOGGING):
+        """Asynchronous version of `run`.
+
+        NOTE: This does not support multiprocessing and is not the preferred
+              way to run a Sanic application.
+        """
+        if log_config:
+            logging.config.dictConfig(log_config)
+        if protocol is None:
+            protocol = (WebSocketProtocol if self.websocket_enabled
+                        else HttpProtocol)
+        if stop_event is not None:
+            if debug:
+                warnings.simplefilter('default')
+            warnings.warn("stop_event will be removed from future versions.",
+                          DeprecationWarning)
+        server_settings = self._helper(
+            host=host, port=port, debug=debug, ssl=ssl, sock=sock,
+            loop=get_event_loop(), protocol=protocol,
+            backlog=backlog, run_async=True,
+            has_log=log_config is not None)
+
+        return await serve(**server_settings)
+
+    async def _run_request_middleware(self, request):
+        # 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:
+                    return response
+        return None
+
+    async def _run_response_middleware(self, request, 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
+        return response
+
+    def _helper(self, host="127.0.0.1", port=8000, debug=False,
+                ssl=None, sock=None, workers=1, loop=None,
+                protocol=HttpProtocol, backlog=100, stop_event=None,
+                register_sys_signals=True, run_async=False, has_log=True):
+        """Helper function used by `run` and `create_server`."""
+
+        if isinstance(ssl, dict):
+            # try common aliaseses
+            cert = ssl.get('cert') or ssl.get('certificate')
+            key = ssl.get('key') or ssl.get('keyfile')
+            if cert is None or key is None:
+                raise ValueError("SSLContext or certificate and key required.")
+            context = create_default_context(purpose=Purpose.CLIENT_AUTH)
+            context.load_cert_chain(cert, keyfile=key)
+            ssl = context
+        if stop_event is not None:
+            if debug:
+                warnings.simplefilter('default')
+            warnings.warn("stop_event will be removed from future versions.",
+                          DeprecationWarning)
+
+        self.error_handler.debug = debug
+        self.debug = debug
+
+        server_settings = {
+            'protocol': protocol,
+            'request_class': self.request_class,
+            'host': host,
+            'port': port,
+            'sock': sock,
+            'ssl': ssl,
+            'signal': Signal(),
+            '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,
+            'keep_alive': self.config.KEEP_ALIVE,
+            'loop': loop,
+            'register_sys_signals': register_sys_signals,
+            'backlog': backlog,
+            'has_log': has_log
+        }
+
+        # -------------------------------------------- #
+        # Register start/stop events
+        # -------------------------------------------- #
+
+        for event_name, settings_name, reverse in (
+                ("before_server_start", "before_start", False),
+                ("after_server_start", "after_start", False),
+                ("before_server_stop", "before_stop", True),
+                ("after_server_stop", "after_stop", True),
+        ):
+            listeners = self.listeners[event_name].copy()
+            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
+        if host and port:
+            proto = "http"
+            if ssl is not None:
+                proto = "https"
+            log.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
+
+        return server_settings

sanic/blueprints.py

@@ -1,7 +1,11 @@
 from collections import defaultdict, namedtuple
 
+from sanic.constants import HTTP_METHODS
+from sanic.views import CompositionView
 
-FutureRoute = namedtuple('Route', ['handler', 'uri', 'methods', 'host'])
+FutureRoute = namedtuple('Route',
+                         ['handler', 'uri', 'methods',
+                          'host', 'strict_slashes'])
 FutureListener = namedtuple('Listener', ['handler', 'uri', 'methods', 'host'])
 FutureMiddleware = namedtuple('Route', ['middleware', 'args', 'kwargs'])
 FutureException = namedtuple('Route', ['handler', 'args', 'kwargs'])
@@ -11,9 +15,9 @@ FutureStatic = namedtuple('Route',
 
 class Blueprint:
     def __init__(self, name, url_prefix=None, host=None):
-        """
-        Creates a new blueprint
-        :param name: Unique name of the blueprint
+        """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
@@ -21,15 +25,14 @@ class Blueprint:
         self.host = host
 
         self.routes = []
+        self.websocket_routes = []
         self.exceptions = []
         self.listeners = defaultdict(list)
         self.middlewares = []
         self.statics = []
 
     def register(self, app, options):
-        """
-        Registers the blueprint to the sanic app.
-        """
+        """Register the blueprint to the sanic app."""
 
         url_prefix = options.get('url_prefix', self.url_prefix)
 
@@ -41,9 +44,22 @@ class Blueprint:
             # Prepend the blueprint URI prefix if available
             uri = url_prefix + future.uri if url_prefix else future.uri
             app.route(
-                uri=uri,
+                uri=uri[1:] if uri.startswith('//') else uri,
                 methods=future.methods,
-                host=future.host or self.host
+                host=future.host or self.host,
+                strict_slashes=future.strict_slashes
+                )(future.handler)
+
+        for future in self.websocket_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.websocket(
+                uri=uri,
+                host=future.host or self.host,
+                strict_slashes=future.strict_slashes
                 )(future.handler)
 
         # Middleware
@@ -65,32 +81,75 @@ class Blueprint:
             app.static(uri, future.file_or_directory,
                        *future.args, **future.kwargs)
 
-    def route(self, uri, methods=frozenset({'GET'}), host=None):
-        """
-        Creates a blueprint route from a decorated function.
-        :param uri: Endpoint at which the route will be accessible.
-        :param methods: List of acceptable HTTP methods.
+        # 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,
+              strict_slashes=False):
+        """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):
-            route = FutureRoute(handler, uri, methods, host)
+            route = FutureRoute(handler, uri, methods, host, strict_slashes)
             self.routes.append(route)
             return handler
         return decorator
 
-    def add_route(self, handler, uri, methods=None, host=None):
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None,
+                  strict_slashes=False):
+        """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
         """
-        Creates a blueprint route from a function.
-        :param handler: Function to handle uri request.
-        :param uri: Endpoint at which the route will be accessible.
-        :param methods: List of acceptable HTTP methods.
+        # 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,
+                   strict_slashes=strict_slashes)(handler)
+        return handler
+
+    def websocket(self, uri, host=None, strict_slashes=False):
+        """Create a blueprint websocket route from a decorated function.
+
+        :param uri: endpoint at which the route will be accessible.
         """
-        route = FutureRoute(handler, uri, methods, host)
-        self.routes.append(route)
+        def decorator(handler):
+            route = FutureRoute(handler, uri, [], host, strict_slashes)
+            self.websocket_routes.append(route)
+            return handler
+        return decorator
+
+    def add_websocket_route(self, handler, uri, host=None):
+        """Create a blueprint websocket 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.
+        :return: function or class instance
+        """
+        self.websocket(uri=uri, host=host)(handler)
         return handler
 
     def listener(self, event):
-        """
-        Create a listener from a decorated function.
+        """Create a listener from a decorated function.
+
         :param event: Event to listen to.
         """
         def decorator(listener):
@@ -99,9 +158,7 @@ class Blueprint:
         return decorator
 
     def middleware(self, *args, **kwargs):
-        """
-        Creates a blueprint middleware from a decorated function.
-        """
+        """Create a blueprint middleware from a decorated function."""
         def register_middleware(_middleware):
             future_middleware = FutureMiddleware(_middleware, args, kwargs)
             self.middlewares.append(future_middleware)
@@ -116,9 +173,7 @@ class Blueprint:
             return register_middleware
 
     def exception(self, *args, **kwargs):
-        """
-        Creates a blueprint exception from a decorated function.
-        """
+        """Create a blueprint exception from a decorated function."""
         def decorator(handler):
             exception = FutureException(handler, args, kwargs)
             self.exceptions.append(exception)
@@ -126,32 +181,39 @@ class Blueprint:
         return decorator
 
     def static(self, uri, file_or_directory, *args, **kwargs):
-        """
-        Creates a blueprint static route from a decorated function.
-        :param uri: Endpoint at which the route will be accessible.
+        """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 get(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["GET"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def post(self, uri, host=None):
-        return self.route(uri, methods=["POST"], host=host)
+    def post(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["POST"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def put(self, uri, host=None):
-        return self.route(uri, methods=["PUT"], host=host)
+    def put(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["PUT"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def head(self, uri, host=None):
-        return self.route(uri, methods=["HEAD"], host=host)
+    def head(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["HEAD"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def options(self, uri, host=None):
-        return self.route(uri, methods=["OPTIONS"], host=host)
+    def options(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["OPTIONS"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def patch(self, uri, host=None):
-        return self.route(uri, methods=["PATCH"], host=host)
+    def patch(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["PATCH"], host=host,
+                          strict_slashes=strict_slashes)
 
-    def delete(self, uri, host=None):
-        return self.route(uri, methods=["DELETE"], host=host)
+    def delete(self, uri, host=None, strict_slashes=False):
+        return self.route(uri, methods=["DELETE"], host=host,
+                          strict_slashes=strict_slashes)

sanic/config.py

@@ -1,9 +1,122 @@
+from sanic.defaultFilter import DefaultFilter
 import os
+import sys
+import syslog
+import platform
 import types
 
+SANIC_PREFIX = 'SANIC_'
+
+_address_dict = {
+    'Windows': ('localhost', 514),
+    'Darwin': '/var/run/syslog',
+    'Linux': '/dev/log',
+    'FreeBSD': '/dev/log'
+}
+
+LOGGING = {
+    'version': 1,
+    'filters': {
+        'accessFilter': {
+            '()': DefaultFilter,
+            'param': [0, 10, 20]
+        },
+        'errorFilter': {
+            '()': DefaultFilter,
+            'param': [30, 40, 50]
+        }
+    },
+    'formatters': {
+        'simple': {
+            'format': '%(asctime)s - (%(name)s)[%(levelname)s]: %(message)s',
+            'datefmt': '%Y-%m-%d %H:%M:%S'
+        },
+        'access': {
+            'format': '%(asctime)s - (%(name)s)[%(levelname)s][%(host)s]: ' +
+                      '%(request)s %(message)s %(status)d %(byte)d',
+            'datefmt': '%Y-%m-%d %H:%M:%S'
+        }
+    },
+    'handlers': {
+        'internal': {
+            'class': 'logging.StreamHandler',
+            'filters': ['accessFilter'],
+            'formatter': 'simple',
+            'stream': sys.stderr
+        },
+        'accessStream': {
+            'class': 'logging.StreamHandler',
+            'filters': ['accessFilter'],
+            'formatter': 'access',
+            'stream': sys.stderr
+        },
+        'errorStream': {
+            'class': 'logging.StreamHandler',
+            'filters': ['errorFilter'],
+            'formatter': 'simple',
+            'stream': sys.stderr
+        },
+        # before you use accessSysLog, be sure that log levels
+        # 0, 10, 20 have been enabled in you syslog configuration
+        # otherwise you won't be able to see the output in syslog
+        # logging file.
+        'accessSysLog': {
+            'class': 'logging.handlers.SysLogHandler',
+            'address': _address_dict.get(platform.system(),
+                                         ('localhost', 514)),
+            'facility': syslog.LOG_DAEMON,
+            'filters': ['accessFilter'],
+            'formatter': 'access'
+        },
+        'errorSysLog': {
+            'class': 'logging.handlers.SysLogHandler',
+            'address': _address_dict.get(platform.system(),
+                                         ('localhost', 514)),
+            'facility': syslog.LOG_DAEMON,
+            'filters': ['errorFilter'],
+            'formatter': 'simple'
+        },
+        'accessTimedRotatingFile': {
+            'class': 'logging.handlers.TimedRotatingFileHandler',
+            'filters': ['accessFilter'],
+            'formatter': 'access',
+            'when': 'D',
+            'interval': 1,
+            'backupCount': 7,
+            'filename': 'access.log'
+        },
+        'errorTimedRotatingFile': {
+            'class': 'logging.handlers.TimedRotatingFileHandler',
+            'filters': ['errorFilter'],
+            'when': 'D',
+            'interval': 1,
+            'backupCount': 7,
+            'filename': 'error.log',
+            'formatter': 'simple'
+        }
+    },
+    'loggers': {
+        'sanic': {
+            'level': 'DEBUG',
+            'handlers': ['internal', 'errorStream']
+        },
+        'network': {
+            'level': 'DEBUG',
+            'handlers': ['accessStream', 'errorStream']
+        }
+    }
+}
+
+# this happens when using container or systems without syslog
+# keep things in config would cause file not exists error
+_addr = LOGGING['handlers']['accessSysLog']['address']
+if type(_addr) is str and not os.path.exists(_addr):
+    LOGGING['handlers'].pop('accessSysLog')
+    LOGGING['handlers'].pop('errorSysLog')
+
 
 class Config(dict):
-    def __init__(self, defaults=None):
+    def __init__(self, defaults=None, load_env=True, keep_alive=True):
         super().__init__(defaults or {})
         self.LOGO = """
                  ▄▄▄▄▄
@@ -28,6 +141,10 @@ class Config(dict):
 """
         self.REQUEST_MAX_SIZE = 100000000  # 100 megababies
         self.REQUEST_TIMEOUT = 60  # 60 seconds
+        self.KEEP_ALIVE = keep_alive
+
+        if load_env:
+            self.load_environment_vars()
 
     def __getattr__(self, attr):
         try:
@@ -39,8 +156,9 @@ class Config(dict):
         self[attr] = value
 
     def from_envvar(self, variable_name):
-        """Loads a configuration from an environment variable pointing to
+        """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.
         """
@@ -52,8 +170,9 @@ class Config(dict):
         return self.from_pyfile(config_file)
 
     def from_pyfile(self, filename):
-        """Updates the values in the config from a Python file. Only the uppercase
-        variables in that module are stored in the config.
+        """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')
@@ -69,7 +188,7 @@ class Config(dict):
         return True
 
     def from_object(self, obj):
-        """Updates the values from the given object.
+        """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.
@@ -88,3 +207,13 @@ class Config(dict):
         for key in dir(obj):
             if key.isupper():
                 self[key] = getattr(obj, key)
+
+    def load_environment_vars(self):
+        """
+        Looks for any SANIC_ prefixed environment variables and applies
+        them to the configuration if present.
+        """
+        for k, v in os.environ.items():
+            if k.startswith(SANIC_PREFIX):
+                _, config_key = k.split(SANIC_PREFIX, 1)
+                self[config_key] = v

sanic/cookies.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 import re
 import string
 
@@ -20,7 +19,7 @@ _Translator.update({
 
 
 def _quote(str):
-    r"""Quote a string for use in a cookie header.
+    """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.
@@ -39,8 +38,7 @@ _is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch
 
 
 class CookieJar(dict):
-    """
-    CookieJar dynamically writes headers as cookies are added and removed
+    """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.
     """
@@ -75,9 +73,7 @@ class CookieJar(dict):
 
 
 class Cookie(dict):
-    """
-    This is a stripped down version of Morsel from SimpleCookie #gottagofast
-    """
+    """A stripped down version of Morsel from SimpleCookie #gottagofast"""
     _keys = {
         "expires": "expires",
         "path": "Path",
@@ -107,13 +103,19 @@ class Cookie(dict):
     def encode(self, encoding):
         output = ['%s=%s' % (self.key, _quote(self.value))]
         for key, value in self.items():
-            if key == 'max-age' and isinstance(value, int):
-                output.append('%s=%d' % (self._keys[key], value))
-            elif key == 'expires' and isinstance(value, datetime):
-                output.append('%s=%s' % (
-                    self._keys[key],
-                    value.strftime("%a, %d-%b-%Y %T GMT")
-                ))
+            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])
@@ -128,9 +130,8 @@ class Cookie(dict):
 
 
 class MultiHeader:
-    """
-    Allows us to set a header within response that has a unique key,
-    but may contain duplicate header names
+    """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

sanic/defaultFilter.py

@@ -0,0 +1,13 @@
+import logging
+
+
+class DefaultFilter(logging.Filter):
+    def __init__(self, param=None):
+        self.param = param
+
+    def filter(self, record):
+        if self.param is None:
+            return True
+        if record.levelno in self.param:
+            return True
+        return False

sanic/exceptions.py

@@ -1,8 +1,3 @@
-from .response import text, html
-from .log import log
-from traceback import format_exc, extract_tb
-import sys
-
 TRACEBACK_STYLE = '''
     <style>
         body {
@@ -52,6 +47,10 @@ TRACEBACK_STYLE = '''
             padding: 5px 10px;
         }
 
+        .tb-border {
+            padding-top: 20px;
+        }
+
         .frame-descriptor {
             background-color: #e2eafb;
         }
@@ -68,20 +67,35 @@ TRACEBACK_WRAPPER_HTML = '''
             {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">
+            {inner_html}
+            <div class="summary">
+                <p>
                 <b>{exc_name}: {exc_value}</b>
-                    while handling uri <code>{uri}</code>
+                    while handling path <code>{path}</code>
                 </p>
             </div>
         </body>
     </html>
 '''
 
+TRACEBACK_WRAPPER_INNER_HTML = '''
+    <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}
+    </div>
+'''
+
+TRACEBACK_BORDER = '''
+    <div class="tb-border">
+        <b><i>
+            The above exception was the direct cause of the
+            following exception:
+        </i></b>
+    </div>
+'''
+
 TRACEBACK_LINE_HTML = '''
     <div class="frame-line">
         <p class="frame-descriptor">
@@ -102,8 +116,10 @@ INTERNAL_SERVER_ERROR_HTML = '''
 
 
 class SanicException(Exception):
+
     def __init__(self, message, status_code=None):
         super().__init__(message)
+
         if status_code is not None:
             self.status_code = status_code
 
@@ -141,85 +157,20 @@ class PayloadTooLarge(SanicException):
     status_code = 413
 
 
-class Handler:
-    handlers = None
-    cached_handlers = None
-    _missing = object()
+class HeaderNotFound(SanicException):
+    status_code = 400
 
-    def __init__(self):
-        self.handlers = []
-        self.cached_handlers = {}
-        self.debug = False
 
-    def _render_traceback_html(self, exception, request):
-        exc_type, exc_value, tb = sys.exc_info()
-        frames = extract_tb(tb)
+class ContentRangeError(SanicException):
+    status_code = 416
 
-        frame_html = []
-        for frame in frames:
-            frame_html.append(TRACEBACK_LINE_HTML.format(frame))
+    def __init__(self, message, content_range):
+        super().__init__(message)
+        self.headers = {
+            'Content-Type': 'text/plain',
+            "Content-Range": "bytes */%s" % (content_range.total,)
+        }
 
-        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.append((exception, handler))
-
-    def lookup(self, exception):
-        handler = self.cached_handlers.get(exception, self._missing)
-        if handler is self._missing:
-            for exception_class, handler in self.handlers:
-                if isinstance(exception, exception_class):
-                    self.cached_handlers[type(exception)] = handler
-                    return handler
-            self.cached_handlers[type(exception)] = None
-            handler = None
-        return 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.lookup(exception)
-        try:
-            response = handler and handler(
-                request=request, exception=exception)
-            if response is None:
-                response = self.default(request=request, exception=exception)
-        except:
-            log.error(format_exc())
-            if self.debug:
-                response_message = (
-                    'Exception raised in exception handler "{}" '
-                    'for uri: "{}"\n{}').format(
-                        handler.__name__, request.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 default(self, request, exception):
-        log.error(format_exc())
-        if isinstance(exception, SanicException):
-            return text(
-                'Error: {}'.format(exception),
-                status=getattr(exception, 'status_code', 500))
-        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 InvalidRangeType(ContentRangeError):
+    pass

sanic/handlers.py

@@ -0,0 +1,171 @@
+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,
+    TRACEBACK_WRAPPER_INNER_HTML,
+    TRACEBACK_BORDER)
+from sanic.log import log
+from sanic.response import text, html
+
+
+class ErrorHandler:
+    handlers = None
+    cached_handlers = None
+    _missing = object()
+
+    def __init__(self):
+        self.handlers = []
+        self.cached_handlers = {}
+        self.debug = False
+
+    def _render_exception(self, exception):
+        frames = extract_tb(exception.__traceback__)
+
+        frame_html = []
+        for frame in frames:
+            frame_html.append(TRACEBACK_LINE_HTML.format(frame))
+
+        return TRACEBACK_WRAPPER_INNER_HTML.format(
+            exc_name=exception.__class__.__name__,
+            exc_value=exception,
+            frame_html=''.join(frame_html))
+
+    def _render_traceback_html(self, exception, request):
+        exc_type, exc_value, tb = sys.exc_info()
+        exceptions = []
+
+        while exc_value:
+            exceptions.append(self._render_exception(exc_value))
+            exc_value = exc_value.__cause__
+
+        return TRACEBACK_WRAPPER_HTML.format(
+            style=TRACEBACK_STYLE,
+            exc_name=exception.__class__.__name__,
+            exc_value=exception,
+            inner_html=TRACEBACK_BORDER.join(reversed(exceptions)),
+            path=request.path)
+
+    def add(self, exception, handler):
+        self.handlers.append((exception, handler))
+
+    def lookup(self, exception):
+        handler = self.cached_handlers.get(exception, self._missing)
+        if handler is self._missing:
+            for exception_class, handler in self.handlers:
+                if isinstance(exception, exception_class):
+                    self.cached_handlers[type(exception)] = handler
+                    return handler
+            self.cached_handlers[type(exception)] = None
+            handler = None
+        return 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.lookup(exception)
+        response = None
+        try:
+            if handler:
+                response = handler(request=request, exception=exception)
+            if response is None:
+                response = self.default(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,3 +1,4 @@
 import logging
 
 log = logging.getLogger('sanic')
+netlog = logging.getLogger('network')

sanic/request.py

@@ -2,11 +2,15 @@ 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 sanic.exceptions import InvalidUsage
+from urllib.parse import parse_qs, urlunparse
 
-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"
@@ -16,8 +20,7 @@ DEFAULT_HTTP_CONTENT_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
     """
 
@@ -31,27 +34,22 @@ class RequestParameters(dict):
 
 
 class Request(dict):
-    """
-    Properties of an HTTP request such as URL, headers, etc.
-    """
+    """Properties of an HTTP request such as URL, headers, etc."""
     __slots__ = (
-        'url', 'headers', 'version', 'method', '_cookies', 'transport',
-        'query_string', 'body',
-        'parsed_json', 'parsed_args', 'parsed_form', 'parsed_files',
-        '_ip',
+        'app', 'headers', 'version', 'method', '_cookies', 'transport',
+        'body', 'parsed_json', 'parsed_args', 'parsed_form', 'parsed_files',
+        '_ip', '_parsed_url', 'uri_template'
     )
 
     def __init__(self, url_bytes, headers, version, method, transport):
         # TODO: Content-Encoding detection
-        url_parsed = parse_url(url_bytes)
-        self.url = url_parsed.path.decode('utf-8')
+        self._parsed_url = parse_url(url_bytes)
+        self.app = None
+
         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 = []
@@ -59,6 +57,7 @@ class Request(dict):
         self.parsed_form = None
         self.parsed_files = None
         self.parsed_args = None
+        self.uri_template = None
         self._cookies = None
 
     @property
@@ -67,20 +66,23 @@ class Request(dict):
             try:
                 self.parsed_json = json_loads(self.body)
             except Exception:
+                if not self.body:
+                    return None
                 raise InvalidUsage("Failed when parsing body as json")
 
         return self.parsed_json
 
     @property
     def token(self):
-        """
-        Attempts to return the auth header token.
+        """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
+        if 'Token ' in auth_header:
+            return auth_header.partition('Token ')[-1]
+        else:
+            return auth_header
 
     @property
     def form(self):
@@ -118,10 +120,13 @@ class Request(dict):
                 self.parsed_args = RequestParameters(
                     parse_qs(self.query_string))
             else:
-                self.parsed_args = {}
-
+                self.parsed_args = RequestParameters()
         return self.parsed_args
 
+    @property
+    def raw_args(self):
+        return {k: v[0] for k, v in self.args.items()}
+
     @property
     def cookies(self):
         if self._cookies is None:
@@ -141,16 +146,55 @@ class Request(dict):
             self._ip = self.transport.get_extra_info('peername')
         return self._ip
 
+    @property
+    def scheme(self):
+        if self.app.websocket_enabled \
+                and self.headers.get('upgrade') == 'websocket':
+            scheme = 'ws'
+        else:
+            scheme = 'http'
+
+        if self.transport.get_extra_info('sslcontext'):
+            scheme += 's'
+
+        return scheme
+
+    @property
+    def host(self):
+        # it appears that httptools doesn't return the host
+        # so pull it from the headers
+        return self.headers.get('Host', '')
+
+    @property
+    def path(self):
+        return self._parsed_url.path.decode('utf-8')
+
+    @property
+    def query_string(self):
+        if self._parsed_url.query:
+            return self._parsed_url.query.decode('utf-8')
+        else:
+            return ''
+
+    @property
+    def url(self):
+        return urlunparse((
+            self.scheme,
+            self.host,
+            self.path,
+            None,
+            self.query_string,
+            None))
+
 
 File = namedtuple('File', ['type', 'body', 'name'])
 
 
 def parse_multipart_form(body, boundary):
-    """
-    Parses a request body and returns fields and files
+    """Parse a request body and returns fields and files
 
-    :param body: Bytes request body
-    :param boundary: Bytes multipart boundary
+    :param body: bytes request body
+    :param boundary: bytes multipart boundary
     :return: fields (RequestParameters), files (RequestParameters)
     """
     files = RequestParameters()

sanic/response.py

@@ -1,10 +1,14 @@
-from aiofiles import open as open_async
 from mimetypes import guess_type
 from os import path
 
-from ujson import dumps as json_dumps
+try:
+    from ujson import dumps as json_dumps
+except:
+    from json import dumps as json_dumps
 
-from .cookies import CookieJar
+from aiofiles import open as open_async
+
+from sanic.cookies import CookieJar
 
 COMMON_STATUS_CODES = {
     200: b'OK',
@@ -73,44 +77,87 @@ ALL_STATUS_CODES = {
 }
 
 
-class HTTPResponse:
-    __slots__ = ('body', 'status', 'content_type', 'headers', '_cookies')
+class BaseHTTPResponse:
+    def _encode_body(self, data):
+        try:
+            # Try to encode it regularly
+            return data.encode()
+        except AttributeError:
+            # Convert it to a str if you can't
+            return str(data).encode()
 
-    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:
+    def _parse_headers(self):
+        headers = b''
+        for name, value in self.headers.items():
             try:
-                # Try to encode it regularly
-                self.body = body.encode()
+                headers += (
+                    b'%b: %b\r\n' % (
+                        name.encode(), value.encode('utf-8')))
             except AttributeError:
-                # Convert it to a str if you can't
-                self.body = str(body).encode()
-        else:
-            self.body = body_bytes
+                headers += (
+                    b'%b: %b\r\n' % (
+                        str(name).encode(), str(value).encode('utf-8')))
 
+        return headers
+
+    @property
+    def cookies(self):
+        if self._cookies is None:
+            self._cookies = CookieJar(self.headers)
+        return self._cookies
+
+
+class StreamingHTTPResponse(BaseHTTPResponse):
+    __slots__ = (
+        'transport', 'streaming_fn',
+        'status', 'content_type', 'headers', '_cookies')
+
+    def __init__(self, streaming_fn, status=200, headers=None,
+                 content_type='text/plain'):
+        self.content_type = content_type
+        self.streaming_fn = streaming_fn
         self.status = status
         self.headers = headers or {}
         self._cookies = None
 
-    def output(self, version="1.1", keep_alive=False, keep_alive_timeout=None):
+    def write(self, data):
+        """Writes a chunk of data to the streaming response.
+
+        :param data: bytes-ish data to be written.
+        """
+        if type(data) != bytes:
+            data = self._encode_body(data)
+
+        self.transport.write(
+            b"%x\r\n%b\r\n" % (len(data), data))
+
+    async def stream(
+            self, version="1.1", keep_alive=False, keep_alive_timeout=None):
+        """Streams headers, runs the `streaming_fn` callback that writes
+        content to the response body, then finalizes the response body.
+        """
+        headers = self.get_headers(
+            version, keep_alive=keep_alive,
+            keep_alive_timeout=keep_alive_timeout)
+        self.transport.write(headers)
+
+        await self.streaming_fn(self)
+        self.transport.write(b'0\r\n\r\n')
+
+    def get_headers(
+            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
 
-        headers = b''
-        if self.headers:
-            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')))
+        self.headers['Transfer-Encoding'] = 'chunked'
+        self.headers.pop('Content-Length', None)
+        self.headers['Content-Type'] = self.headers.get(
+            'Content-Type', self.content_type)
+
+        headers = self._parse_headers()
 
         # Try to pull from the common codes first
         # Speeds up response rate 6% over pulling from all
@@ -119,21 +166,65 @@ class HTTPResponse:
             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'%b'
+                b'%b\r\n') % (
+                   version.encode(),
+                   self.status,
+                   status,
+                   timeout_header,
+                   headers
+               )
+
+
+class HTTPResponse(BaseHTTPResponse):
+    __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 = self._encode_body(body)
+        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 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 = self._parse_headers()
+
+        # 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, b'UNKNOWN RESPONSE')
+
+        return (b'HTTP/%b %d %b\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,
-            self.content_type.encode(),
-            len(self.body),
-            b'keep-alive' if keep_alive else b'close',
-            timeout_header,
-            headers,
-            self.body
-        )
+                   version.encode(),
+                   self.status,
+                   status,
+                   b'keep-alive' if keep_alive else b'close',
+                   timeout_header,
+                   headers,
+                   self.body
+               )
 
     @property
     def cookies(self):
@@ -148,21 +239,37 @@ def json(body, status=200, headers=None, **kwargs):
     :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.
+    :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):
+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")
+    return HTTPResponse(
+        body, status=status, headers=headers,
+        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):
@@ -176,17 +283,24 @@ def html(body, status=200, headers=None):
                         content_type="text/html; charset=utf-8")
 
 
-async def file(location, mime_type=None, headers=None):
-    """
-    Returns response object with file data.
+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:
-        out_stream = await _file.read()
+        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'
 
@@ -196,16 +310,43 @@ async def file(location, mime_type=None, headers=None):
                         body_bytes=out_stream)
 
 
+def stream(
+        streaming_fn, status=200, headers=None,
+        content_type="text/plain; charset=utf-8"):
+    """Accepts an coroutine `streaming_fn` which can be used to
+    write chunks to a streaming response. Returns a `StreamingHTTPResponse`.
+
+    Example usage::
+
+        @app.route("/")
+        async def index(request):
+            async def streaming_fn(response):
+                await response.write('foo')
+                await response.write('bar')
+
+            return stream(streaming_fn, content_type='text/plain')
+
+    :param streaming_fn: A coroutine accepts a response and
+        writes content to that response.
+    :param mime_type: Specific mime_type.
+    :param headers: Custom Headers.
+    """
+    return StreamingHTTPResponse(
+        streaming_fn,
+        headers=headers,
+        content_type=content_type,
+        status=status
+    )
+
+
 def redirect(to, headers=None, status=302,
              content_type="text/html; charset=utf-8"):
-    """
-    Aborts execution and causes a 302 redirect (by default).
+    """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
+    :param content_type: the content type (string) of the response
     :returns: the redirecting Response
     """
     headers = headers or {}

sanic/router.py

@@ -1,12 +1,14 @@
 import re
 from collections import defaultdict, namedtuple
+from collections.abc import Iterable
 from functools import lru_cache
-from .exceptions import NotFound, InvalidUsage
-from .views import CompositionView
+
+from sanic.exceptions import NotFound, InvalidUsage
+from sanic.views import CompositionView
 
 Route = namedtuple(
     'Route',
-    ['handler', 'methods', 'pattern', 'parameters', 'name'])
+    ['handler', 'methods', 'pattern', 'parameters', 'name', 'uri'])
 Parameter = namedtuple('Parameter', ['name', 'cast'])
 
 REGEX_TYPES = {
@@ -14,6 +16,7 @@ REGEX_TYPES = {
     'int': (int, r'\d+'),
     'number': (float, r'[0-9\\.]+'),
     'alpha': (str, r'[A-Za-z]+'),
+    'path': (str, r'[^/].*?'),
 }
 
 ROUTER_CACHE_SIZE = 1024
@@ -32,8 +35,7 @@ class RouteDoesNotExist(Exception):
 
 
 class Router:
-    """
-    Router supports basic routing with parameters and method checks
+    """Router supports basic routing with parameters and method checks
 
     Usage:
 
@@ -68,14 +70,17 @@ class Router:
         self.routes_static = {}
         self.routes_dynamic = defaultdict(list)
         self.routes_always_check = []
-        self.hosts = None
+        self.hosts = set()
 
-    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]')
+    @classmethod
+    def parse_parameter_string(cls, 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
@@ -93,33 +98,53 @@ class Router:
 
         return name, _type, pattern
 
-    def add(self, uri, methods, handler, host=None):
-        """
-        Adds a handler to the route list
+    def add(self, uri, methods, handler, host=None, strict_slashes=False):
 
-        :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.
+        # add regular version
+        self._add(uri, methods, handler, host)
+
+        if strict_slashes:
+            return
+
+        # Add versions with and without trailing /
+        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:
-            # we want to track if there are any
-            # vhosts on the Router instance so that we can
-            # default to the behavior without vhosts
-            if self.hosts is None:
-                self.hosts = set(host)
-            else:
-                if isinstance(host, list):
-                    host = set(host)
-                self.hosts.add(host)
             if isinstance(host, str):
                 uri = host + uri
+                self.hosts.add(host)
+
             else:
-                for h in host:
-                    self.add(uri, methods, handler, h)
+                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
 
         # Dict for faster lookups of if method allowed
@@ -138,10 +163,10 @@ class Router:
             parameters.append(parameter)
 
             # Mark the whole route as unhashable if it has the hash key in it
-            if re.search('(^|[^^]){1}/', pattern):
+            if re.search(r'(^|[^^]){1}/', pattern):
                 properties['unhashable'] = True
             # Mark the route as unhashable if it matches the hash key
-            elif re.search(pattern, '/'):
+            elif re.search(r'/', pattern):
                 properties['unhashable'] = True
 
             return '({})'.format(pattern)
@@ -200,7 +225,7 @@ class Router:
 
             route = Route(
                 handler=handler, methods=methods, pattern=pattern,
-                parameters=parameters, name=handler_name)
+                parameters=parameters, name=handler_name, uri=uri)
 
         self.routes_all[uri] = route
         if properties['unhashable']:
@@ -239,8 +264,7 @@ class Router:
 
     @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.
+        """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)
@@ -255,26 +279,30 @@ class Router:
         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
         """
-        if self.hosts is None:
-            return self._get(request.url, request.method, '')
-        else:
-            return self._get(request.url, request.method,
+        # No virtual hosts specified; default behavior
+        if not self.hosts:
+            return self._get(request.path, request.method, '')
+        # virtual hosts specified; try to match route to the host header
+        try:
+            return self._get(request.path, request.method,
                              request.headers.get("Host", ''))
+        # try default hosts
+        except NotFound:
+            return self._get(request.path, request.method, '')
 
     @lru_cache(maxsize=ROUTER_CACHE_SIZE)
     def _get(self, url, method, host):
-        """
-        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.  Internal method for caching.
-        :param url: Request URL
-        :param method: Request method
+
+        :param url: request URL
+        :param method: request method
         :return: handler, arguments, keyword arguments
         """
         url = host + url
@@ -316,4 +344,4 @@ class Router:
         route_handler = route.handler
         if hasattr(route_handler, 'handlers'):
             route_handler = route_handler.handlers[method]
-        return route_handler, [], kwargs
+        return route_handler, [], kwargs, route.uri

sanic/sanic.py

@@ -1,513 +0,0 @@
-import logging
-from asyncio import get_event_loop
-from collections import deque
-from functools import partial
-from inspect import isawaitable, stack, getmodulename
-import re
-from traceback import format_exc
-from urllib.parse import urlencode, urlunparse
-import warnings
-
-from .config import Config
-from .constants import HTTP_METHODS
-from .exceptions import Handler
-from .exceptions import ServerError, URLBuildError
-from .log import log
-from .response import HTTPResponse
-from .router import Router
-from .server import serve, serve_multiple, HttpProtocol
-from .static import register as static_register
-
-
-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)
-        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 Handler()
-        self.config = Config()
-        self.request_middleware = deque()
-        self.response_middleware = deque()
-        self.blueprints = {}
-        self._blueprint_order = []
-        self.debug = None
-        self.sock = None
-        self.processes = None
-
-        # Register alternative method names
-        self.go_fast = self.run
-
-    # -------------------------------------------------------------------- #
-    # Registration
-    # -------------------------------------------------------------------- #
-
-    # Decorator
-    def route(self, uri, methods=frozenset({'GET'}), host=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
-        """
-
-        # 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=["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)
-
-    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
-        :return: function or class instance
-        """
-        # Handle HTTPMethodView differently
-        if hasattr(handler, 'view_class'):
-            methods = frozenset(HTTP_METHODS)
-        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):
-        """
-        Decorates 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, *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.appendleft(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
-
-    # Static Files
-    def static(self, uri, file_or_directory, pattern='.+',
-               use_modified_since=True):
-        """
-        Registers a root to serve files from.  The input can either be a file
-        or a directory.  See
-        """
-        static_register(self, uri, file_or_directory, pattern,
-                        use_modified_since)
-
-    def 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)
-
-    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):
-        """Builds 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: A 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))
-
-        out = uri
-
-        # find all the parameters we will need to build in the URL
-        matched_params = re.findall(
-            self.router.parameter_pattern, uri)
-
-        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
-        if kwargs:
-            query_string = urlencode(kwargs)
-            out = urlunparse((
-                '', '', out,
-                '', query_string, ''
-            ))
-
-        return out
-
-    # -------------------------------------------------------------------- #
-    # Request Handling
-    # -------------------------------------------------------------------- #
-
-    def converted_response_type(self, response):
-        pass
-
-    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:
-            # -------------------------------------------- #
-            # Request Middleware
-            # -------------------------------------------- #
-
-            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)
-
-    # -------------------------------------------------------------------- #
-    # 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):
-        """
-        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 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 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:
-            if workers == 1:
-                serve(**server_settings)
-            else:
-                serve_multiple(server_settings, workers, stop_event)
-
-        except Exception as e:
-            log.exception(
-                'Experienced exception while trying to serve')
-
-        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`.
-        """
-        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,
-            protocol=protocol, backlog=backlog, stop_event=stop_event,
-            run_async=True)
-
-        # Serve
-        proto = "http"
-        if ssl is not None:
-            proto = "https"
-        log.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
-
-        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)
-
-        self.error_handler.debug = debug
-        self.debug = debug
-        self.loop = loop = get_event_loop()
-
-        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, args, reverse in (
-                ("before_server_start", "before_start", before_start, False),
-                ("after_server_start", "after_start", after_start, False),
-                ("before_server_stop", "before_stop", before_stop, True),
-                ("after_server_stop", "after_stop", after_stop, True),
-                ):
-            listeners = []
-            for blueprint in self.blueprints.values():
-                listeners += blueprint.listeners[event_name]
-            if args:
-                if callable(args):
-                    args = [args]
-                listeners += 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/server.py

@@ -3,27 +3,32 @@ import os
 import traceback
 from functools import partial
 from inspect import isawaitable
-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 multiprocessing import Process
+from signal import (
+    SIGTERM, SIGINT,
+    signal as signal_func,
+    Signals
+)
+from socket import (
+    socket,
+    SOL_SOCKET,
+    SO_REUSEADDR,
+)
 from time import time
-import warnings
 
 from httptools import HttpRequestParser
 from httptools.parser.errors import HttpParserError
 
-from .exceptions import ServerError
-
 try:
     import uvloop as async_loop
 except ImportError:
     async_loop = asyncio
 
-from .log import log
-from .request import Request
-from .exceptions import RequestTimeout, PayloadTooLarge, InvalidUsage
+from sanic.log import log, netlog
+from sanic.response import HTTPResponse
+from sanic.request import Request
+from sanic.exceptions import (
+    RequestTimeout, PayloadTooLarge, InvalidUsage, ServerError)
 
 current_time = None
 
@@ -33,8 +38,7 @@ class Signal:
 
 
 class CIDict(dict):
-    """
-    Case Insensitive dict where all keys are converted to lowercase
+    """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
     """
@@ -60,12 +64,16 @@ class HttpProtocol(asyncio.Protocol):
         'parser', 'request', 'url', 'headers',
         # request config
         'request_handler', 'request_timeout', 'request_max_size',
+        'request_class',
+        # enable or disable access log / error log purpose
+        'has_log',
         # connection management
         '_total_request_size', '_timeout_handler', '_last_communication_time')
 
     def __init__(self, *, loop, request_handler, error_handler,
                  signal=Signal(), connections=set(), request_timeout=60,
-                 request_max_size=None):
+                 request_max_size=None, request_class=None, has_log=True,
+                 keep_alive=True):
         self.loop = loop
         self.transport = None
         self.request = None
@@ -73,15 +81,24 @@ class HttpProtocol(asyncio.Protocol):
         self.url = None
         self.headers = None
         self.signal = signal
+        self.has_log = has_log
         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.request_class = request_class or Request
         self._total_request_size = 0
         self._timeout_handler = None
         self._last_request_time = None
         self._request_handler_task = None
+        self._keep_alive = keep_alive
+
+    @property
+    def keep_alive(self):
+        return (self._keep_alive
+                and not self.signal.stopped
+                and self.parser.should_keep_alive())
 
     # -------------------------------------------- #
     # Connection
@@ -147,7 +164,7 @@ class HttpProtocol(asyncio.Protocol):
         self.headers.append((name.decode().casefold(), value.decode()))
 
     def on_headers_complete(self):
-        self.request = Request(
+        self.request = self.request_class(
             url_bytes=self.url,
             headers=CIDict(self.headers),
             version=self.parser.get_http_version(),
@@ -159,34 +176,94 @@ class HttpProtocol(asyncio.Protocol):
         self.request.body.append(body)
 
     def on_message_complete(self):
-        if self.request.body:
-            self.request.body = b''.join(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))
+            self.request_handler(
+                self.request,
+                self.write_response,
+                self.stream_response))
 
     # -------------------------------------------- #
     # Responding
     # -------------------------------------------- #
-
     def write_response(self, response):
+        """
+        Writes response content synchronously to the transport.
+        """
         try:
-            keep_alive = (
-                self.parser.should_keep_alive() and not self.signal.stopped)
+            keep_alive = self.keep_alive
             self.transport.write(
                 response.output(
-                    self.request.version, keep_alive, self.request_timeout))
+                    self.request.version, keep_alive,
+                    self.request_timeout))
+            if self.has_log:
+                netlog.info('', extra={
+                    'status': response.status,
+                    'byte': len(response.body),
+                    'host': '%s:%d' % self.request.ip,
+                    'request': '%s %s' % (self.request.method,
+                                          self.request.url)
+                })
+        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(e))
+                "Writing response failed, connection closed {}".format(
+                    repr(e)))
+        finally:
+            if not keep_alive:
+                self.transport.close()
+            else:
+                self._last_request_time = current_time
+                self.cleanup()
+
+    async def stream_response(self, response):
+        """
+        Streams a response to the client asynchronously. Attaches
+        the transport to the response so the response consumer can
+        write to the response as needed.
+        """
+
+        try:
+            keep_alive = self.keep_alive
+            response.transport = self.transport
+            await response.stream(
+                self.request.version, keep_alive, self.request_timeout)
+            if self.has_log:
+                netlog.info('', extra={
+                    'status': response.status,
+                    'byte': -1,
+                    'host': '%s:%d' % self.request.ip,
+                    'request': '%s %s' % (self.request.method,
+                                          self.request.url)
+                })
+        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()
 
@@ -198,16 +275,31 @@ class HttpProtocol(asyncio.Protocol):
         except RuntimeError:
             log.error(
                 'Connection lost before error written @ {}'.format(
-                    self.request.ip))
+                    self.request.ip if self.request else 'Unknown'))
         except Exception as e:
             self.bail_out(
-                "Writing error failed, connection closed {}".format(e),
+                "Writing error failed, connection closed {}".format(repr(e)),
                 from_error=True)
         finally:
+            if self.has_log:
+                extra = {
+                    'status': response.status,
+                    'host': '',
+                    'request': str(self.request) + str(self.url)
+                }
+                if response and isinstance(response, HTTPResponse):
+                    extra['byte'] = len(response.body)
+                else:
+                    extra['byte'] = -1
+                if self.request:
+                    extra['host'] = '%s:%d' % self.request.ip,
+                    extra['request'] = '%s %s' % (self.request.method,
+                                                  self.url)
+                netlog.info('', extra=extra)
             self.transport.close()
 
     def bail_out(self, message, from_error=False):
-        if from_error and self.transport.is_closing():
+        if from_error or self.transport.is_closing():
             log.error(
                 ("Transport closed @ {} and exception "
                  "experienced during error handling").format(
@@ -228,8 +320,8 @@ class HttpProtocol(asyncio.Protocol):
         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:
@@ -239,9 +331,8 @@ class HttpProtocol(asyncio.Protocol):
 
 
 def update_current_time(loop):
-    """
-    Caches the current time, since it is needed
-    at the end of every keep-alive request to update the request timeout time
+    """Cache the current time, since it is needed at the end of every
+    keep-alive request to update the request timeout time
 
     :param loop:
     :return:
@@ -252,49 +343,49 @@ def 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
     """
-    if events:
-        if not isinstance(events, list):
-            events = [events]
-        for event in events:
-            result = event(loop)
-            if isawaitable(result):
-                loop.run_until_complete(result)
+    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):
-    """
-    Starts asynchronous HTTP Server on an individual process.
+          register_sys_signals=True, run_async=False, connections=None,
+          signal=Signal(), request_class=None, has_log=True, keep_alive=True):
+    """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
+    :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
+    :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
+    :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
+    :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)
+                       `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
+    :param protocol: subclass of asyncio protocol class
+    :param request_class: Request class to use
+    :param has_log: disable/enable access log and error log
     :return: Nothing
     """
     if not run_async:
@@ -306,8 +397,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
 
     trigger_events(before_start, loop)
 
-    connections = set()
-    signal = Signal()
+    connections = connections if connections is not None else set()
     server = partial(
         protocol,
         loop=loop,
@@ -317,6 +407,9 @@ def serve(host, port, request_handler, error_handler, before_start=None,
         error_handler=error_handler,
         request_timeout=request_timeout,
         request_max_size=request_max_size,
+        request_class=request_class,
+        has_log=has_log,
+        keep_alive=keep_alive,
     )
 
     server_coroutine = loop.create_server(
@@ -346,8 +439,11 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     # Register signals for graceful termination
     if register_sys_signals:
         for _signal in (SIGINT, SIGTERM):
-            loop.add_signal_handler(_signal, loop.stop)
-
+            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))
@@ -375,37 +471,35 @@ def serve(host, port, request_handler, error_handler, before_start=None,
         loop.close()
 
 
-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.
+def serve_multiple(server_settings, workers):
+    """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
+    # Handling when custom socket is not provided.
+    if server_settings.get('sock') is None:
+        sock = socket()
+        sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        sock.bind((server_settings['host'], server_settings['port']))
+        sock.set_inheritable(True)
+        server_settings['sock'] = sock
+        server_settings['host'] = None
+        server_settings['port'] = None
 
-    if stop_event is None:
-        stop_event = Event()
+    def sig_handler(signal, frame):
+        log.info("Received signal {}. Shutting down.".format(
+            Signals(signal).name))
+        for process in processes:
+            os.kill(process.pid, SIGINT)
 
-    signal_func(SIGINT, lambda s, f: stop_event.set())
-    signal_func(SIGTERM, lambda s, f: stop_event.set())
+    signal_func(SIGINT, lambda s, f: sig_handler(s, f))
+    signal_func(SIGTERM, lambda s, f: sig_handler(s, f))
 
     processes = []
     for _ in range(workers):
@@ -420,6 +514,4 @@ def serve_multiple(server_settings, workers, stop_event=None):
     # the above processes will block this until they're stopped
     for process in processes:
         process.terminate()
-    sock.close()
-
-    asyncio.get_event_loop().stop()
+    server_settings.get('sock').close()

sanic/static.py

@@ -1,19 +1,28 @@
-from aiofiles.os import stat
+from mimetypes import guess_type
 from os import path
 from re import sub
 from time import strftime, gmtime
 from urllib.parse import unquote
 
-from .exceptions import FileNotFound, InvalidUsage
-from .response import file, HTTPResponse
+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):
-    # TODO: Though sanic is not a file server, I feel like we should atleast
+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
     """
-    Registers a static directory handler with Sanic by adding a route to the
+    Register a static directory handler with Sanic by adding a route to the
     router and registering a handler.
 
     :param app: Sanic
@@ -23,8 +32,9 @@ def register(app, uri, file_or_directory, pattern, use_modified_since):
     :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):
@@ -38,30 +48,57 @@ def register(app, uri, file_or_directory, pattern, use_modified_since):
         # 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
+        root_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)
+        file_path = path.abspath(unquote(file_path))
+        if not file_path.startswith(path.abspath(unquote(root_path))):
+            raise FileNotFound('File not found',
+                               path=file_or_directory,
+                               relative_url=file_uri)
         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))
+                modified_since = strftime(
+                    '%a, %d %b %Y %H:%M:%S GMT', gmtime(stats.st_mtime))
                 if request.headers.get('If-Modified-Since') == modified_since:
                     return HTTPResponse(status=304)
                 headers['Last-Modified'] = modified_since
-
-            return await file(file_path, headers=headers)
-        except:
+            _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'])(_handler)
+    app.route(uri, methods=['GET', 'HEAD'])(_handler)

sanic/testing.py

@@ -0,0 +1,100 @@
+import traceback
+
+from sanic.log import log
+
+HOST = '127.0.0.1'
+PORT = 42101
+
+
+class SanicTestClient:
+    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)
+        conn = aiohttp.TCPConnector(verify_ssl=False)
+        async with aiohttp.ClientSession(
+                cookies=cookies, connector=conn) as session:
+            async with getattr(
+                    session, method.lower())(url, *args, **kwargs) as response:
+                try:
+                    response.text = await response.text()
+                except UnicodeDecodeError as e:
+                    response.text = None
+                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:
+                log.error(
+                    'Exception:\n{}'.format(traceback.format_exc()))
+                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,59 +0,0 @@
-import aiohttp
-from sanic.log import log
-
-HOST = '127.0.0.1'
-PORT = 42101
-
-
-async def local_request(method, uri, cookies=None, *args, **kwargs):
-    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(app, 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
-        app.request_middleware.appendleft(_collect_request)
-
-    async def _collect_response(sanic, loop):
-        try:
-            response = await local_request(method, uri, *request_args,
-                                           **request_kwargs)
-            results[-1] = response
-        except Exception as e:
-            exceptions.append(e)
-        app.stop()
-
-    app.run(host=HOST, debug=debug, port=PORT,
-            after_start=_collect_response, **server_kwargs)
-
-    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))

sanic/views.py

@@ -1,8 +1,9 @@
-from .exceptions import InvalidUsage
+from sanic.exceptions import InvalidUsage
+from sanic.constants import HTTP_METHODS
 
 
 class HTTPMethodView:
-    """ Simple class based implementation of view for the sanic.
+    """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.
 
@@ -40,17 +41,12 @@ class HTTPMethodView:
 
     def dispatch_request(self, request, *args, **kwargs):
         handler = getattr(self, request.method.lower(), None)
-        if handler:
-            return handler(request, *args, **kwargs)
-        raise InvalidUsage(
-            'Method {} not allowed for URL {}'.format(
-                request.method, request.url), status_code=405)
+        return handler(request, *args, **kwargs)
 
     @classmethod
     def as_view(cls, *class_args, **class_kwargs):
-        """ Converts the class into an actual view function that can be used
-        with the routing system.
-
+        """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)
@@ -69,7 +65,7 @@ class HTTPMethodView:
 
 
 class CompositionView:
-    """ Simple method-function mapped view for the sanic.
+    """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.
 
@@ -89,15 +85,15 @@ class CompositionView:
 
     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 KeyError(
-                    'Method {} already is registered.'.format(method))
+                raise InvalidUsage(
+                    'Method {} is already registered.'.format(method))
             self.handlers[method] = handler
 
     def __call__(self, request, *args, **kwargs):
-        handler = self.handlers.get(request.method.upper(), None)
-        if handler is None:
-            raise InvalidUsage(
-                'Method {} not allowed for URL {}'.format(
-                    request.method, request.url), status_code=405)
+        handler = self.handlers[request.method.upper()]
         return handler(request, *args, **kwargs)

sanic/websocket.py

@@ -0,0 +1,67 @@
+from sanic.exceptions import InvalidUsage
+from sanic.server import HttpProtocol
+from httptools import HttpParserUpgrade
+from websockets import handshake, WebSocketCommonProtocol, InvalidHandshake
+from websockets import ConnectionClosed  # noqa
+
+
+class WebSocketProtocol(HttpProtocol):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.websocket = None
+
+    def connection_timeout(self):
+        # timeouts make no sense for websocket routes
+        if self.websocket is None:
+            super().connection_timeout()
+
+    def connection_lost(self, exc):
+        if self.websocket is not None:
+            self.websocket.connection_lost(exc)
+        super().connection_lost(exc)
+
+    def data_received(self, data):
+        if self.websocket is not None:
+            # pass the data to the websocket protocol
+            self.websocket.data_received(data)
+        else:
+            try:
+                super().data_received(data)
+            except HttpParserUpgrade:
+                # this is okay, it just indicates we've got an upgrade request
+                pass
+
+    def write_response(self, response):
+        if self.websocket is not None:
+            # websocket requests do not write a response
+            self.transport.close()
+        else:
+            super().write_response(response)
+
+    async def websocket_handshake(self, request):
+        # let the websockets package do the handshake with the client
+        headers = []
+
+        def get_header(k):
+            return request.headers.get(k, '')
+
+        def set_header(k, v):
+            headers.append((k, v))
+
+        try:
+            key = handshake.check_request(get_header)
+            handshake.build_response(set_header, key)
+        except InvalidHandshake:
+            raise InvalidUsage('Invalid websocket request')
+
+        # write the 101 response back to the client
+        rv = b'HTTP/1.1 101 Switching Protocols\r\n'
+        for k, v in headers:
+            rv += k.encode('utf-8') + b': ' + v.encode('utf-8') + b'\r\n'
+        rv += b'\r\n'
+        request.transport.write(rv)
+
+        # hook up the websocket protocol
+        self.websocket = WebSocketCommonProtocol()
+        self.websocket.connection_made(request.transport)
+        return self.websocket

sanic/worker.py

@@ -0,0 +1,166 @@
+import os
+import sys
+import signal
+import asyncio
+import logging
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+import uvloop
+import gunicorn.workers.base as base
+
+from sanic.server import trigger_events, serve, HttpProtocol, Signal
+from sanic.websocket import WebSocketProtocol
+
+
+class GunicornWorker(base.Worker):
+
+    def __init__(self, *args, **kw):  # pragma: no cover
+        super().__init__(*args, **kw)
+        cfg = self.cfg
+        if cfg.is_ssl:
+            self.ssl_context = self._create_ssl_context(cfg)
+        else:
+            self.ssl_context = None
+        self.servers = []
+        self.connections = set()
+        self.exit_code = 0
+        self.signal = Signal()
+
+    def init_process(self):
+        # create new event_loop after fork
+        asyncio.get_event_loop().close()
+
+        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+        super().init_process()
+
+    def run(self):
+        is_debug = self.log.loglevel == logging.DEBUG
+        protocol = (WebSocketProtocol if self.app.callable.websocket_enabled
+                    else HttpProtocol)
+        self._server_settings = self.app.callable._helper(
+            host=None,
+            port=None,
+            loop=self.loop,
+            debug=is_debug,
+            protocol=protocol,
+            ssl=self.ssl_context,
+            run_async=True)
+        self._server_settings['signal'] = self.signal
+        self._server_settings.pop('sock')
+        trigger_events(self._server_settings.get('before_start', []),
+                       self.loop)
+        self._server_settings['before_start'] = ()
+
+        self._runner = asyncio.ensure_future(self._run(), loop=self.loop)
+        try:
+            self.loop.run_until_complete(self._runner)
+            self.app.callable.is_running = True
+            trigger_events(self._server_settings.get('after_start', []),
+                           self.loop)
+            self.loop.run_until_complete(self._check_alive())
+            trigger_events(self._server_settings.get('before_stop', []),
+                           self.loop)
+            self.loop.run_until_complete(self.close())
+        finally:
+            trigger_events(self._server_settings.get('after_stop', []),
+                           self.loop)
+            self.loop.close()
+
+        sys.exit(self.exit_code)
+
+    async def close(self):
+        if self.servers:
+            # stop accepting connections
+            self.log.info("Stopping server: %s, connections: %s",
+                          self.pid, len(self.connections))
+            for server in self.servers:
+                server.close()
+                await server.wait_closed()
+            self.servers.clear()
+
+            # prepare connections for closing
+            self.signal.stopped = True
+            for conn in self.connections:
+                conn.close_if_idle()
+
+            while self.connections:
+                await asyncio.sleep(0.1)
+
+    async def _run(self):
+        for sock in self.sockets:
+            self.servers.append(await serve(
+                sock=sock,
+                connections=self.connections,
+                **self._server_settings
+            ))
+
+    async def _check_alive(self):
+        # If our parent changed then we shut down.
+        pid = os.getpid()
+        try:
+            while self.alive:
+                self.notify()
+
+                if pid == os.getpid() and self.ppid != os.getppid():
+                    self.alive = False
+                    self.log.info("Parent changed, shutting down: %s", self)
+                else:
+                    await asyncio.sleep(1.0, loop=self.loop)
+        except (Exception, BaseException, GeneratorExit, KeyboardInterrupt):
+            pass
+
+    @staticmethod
+    def _create_ssl_context(cfg):
+        """ Creates SSLContext instance for usage in asyncio.create_server.
+        See ssl.SSLSocket.__init__ for more details.
+        """
+        ctx = ssl.SSLContext(cfg.ssl_version)
+        ctx.load_cert_chain(cfg.certfile, cfg.keyfile)
+        ctx.verify_mode = cfg.cert_reqs
+        if cfg.ca_certs:
+            ctx.load_verify_locations(cfg.ca_certs)
+        if cfg.ciphers:
+            ctx.set_ciphers(cfg.ciphers)
+        return ctx
+
+    def init_signals(self):
+        # Set up signals through the event loop API.
+
+        self.loop.add_signal_handler(signal.SIGQUIT, self.handle_quit,
+                                     signal.SIGQUIT, None)
+
+        self.loop.add_signal_handler(signal.SIGTERM, self.handle_exit,
+                                     signal.SIGTERM, None)
+
+        self.loop.add_signal_handler(signal.SIGINT, self.handle_quit,
+                                     signal.SIGINT, None)
+
+        self.loop.add_signal_handler(signal.SIGWINCH, self.handle_winch,
+                                     signal.SIGWINCH, None)
+
+        self.loop.add_signal_handler(signal.SIGUSR1, self.handle_usr1,
+                                     signal.SIGUSR1, None)
+
+        self.loop.add_signal_handler(signal.SIGABRT, self.handle_abort,
+                                     signal.SIGABRT, None)
+
+        # Don't let SIGTERM and SIGUSR1 disturb active requests
+        # by interrupting system calls
+        signal.siginterrupt(signal.SIGTERM, False)
+        signal.siginterrupt(signal.SIGUSR1, False)
+
+    def handle_quit(self, sig, frame):
+        self.alive = False
+        self.cfg.worker_int(self)
+
+    def handle_abort(self, sig, frame):
+        self.alive = False
+        self.exit_code = 1
+        self.cfg.worker_abort(self)

setup.py

@@ -4,38 +4,77 @@ Sanic
 import codecs
 import os
 import re
+from distutils.errors import DistutilsPlatformError
+from distutils.util import strtobool
+
 from setuptools import setup
 
 
-with codecs.open(os.path.join(os.path.abspath(os.path.dirname(
-        __file__)), 'sanic', '__init__.py'), 'r', 'latin1') as fp:
+def open_local(paths, mode='r', encoding='utf8'):
+    path = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)),
+        *paths
+    )
+
+    return codecs.open(path, mode, encoding)
+
+
+with open_local(['sanic', '__init__.py'], encoding='latin1') as fp:
     try:
         version = re.findall(r"^__version__ = '([^']+)'\r?$",
                              fp.read(), re.M)[0]
     except IndexError:
         raise RuntimeError('Unable to determine version.')
 
-setup(
-    name='sanic',
-    version=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',
-    packages=['sanic'],
-    platforms='any',
-    install_requires=[
-        'uvloop>=0.5.3',
-        'httptools>=0.0.9',
-        'ujson>=1.35',
-        'aiofiles>=0.3.0',
-    ],
-    classifiers=[
+
+with open_local(['README.rst']) as rm:
+    long_description = rm.read()
+
+setup_kwargs = {
+    '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'),
+    'long_description': long_description,
+    'packages': ['sanic'],
+    'platforms': 'any',
+    'classifiers': [
         'Development Status :: 2 - Pre-Alpha',
         'Environment :: Web Environment',
         'License :: OSI Approved :: MIT License',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
     ],
-)
+}
+
+ujson = 'ujson>=1.35'
+uvloop = 'uvloop>=0.5.3'
+
+requirements = [
+    'httptools>=0.0.9',
+    uvloop,
+    ujson,
+    'aiofiles>=0.3.0',
+    'websockets>=3.2',
+]
+if strtobool(os.environ.get("SANIC_NO_UJSON", "no")):
+    print("Installing without uJSON")
+    requirements.remove(ujson)
+
+if strtobool(os.environ.get("SANIC_NO_UVLOOP", "no")):
+    print("Installing without uvLoop")
+    requirements.remove(uvloop)
+
+try:
+    setup_kwargs['install_requires'] = requirements
+    setup(**setup_kwargs)
+except DistutilsPlatformError as exception:
+    requirements.remove(ujson)
+    requirements.remove(uvloop)
+    print("Installing without uJSON or uvLoop")
+    setup_kwargs['install_requires'] = requirements
+    setup(**setup_kwargs)

tests/certs/selfsigned.cert

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIJAO6wb0FSc/rNMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
+BAYTAlVTMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMTcwMzAzMTUyODAzWhcNMTkxMTI4MTUyODAzWjBF
+MQswCQYDVQQGEwJVUzETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAsy7Zb3p4yCEnUtPLwqeJrwj9u/ZmcFCrMAktFBx9hG6rY2r7mdB6Bflh
+V5cUJXxnsNiDpYcxGhA8kry7pEork1vZ05DyZC9ulVlvxBouVShBcLLwdpaoTGqE
+vYtejv6x7ogwMXOjkWWb1WpOv4CVhpeXJ7O/d1uAiYgcUpTpPp4ONG49IAouBHq3
+h+o4nVvNfB0J8gaCtTsTZqi1Wt8WYs3XjxGJaKh//ealfRe1kuv40CWQ8gjaC8/1
+w9pHdom3Wi/RwfDM3+dVGV6M5lAbPXMB4RK17Hk9P3hlJxJOpKBdgcBJPXtNrTwf
+qEWWxk2mB/YVyB84AxjkkNoYyi2ggQIDAQABo4GnMIGkMB0GA1UdDgQWBBRa46Ix
+9s9tmMqu+Zz1mocHghm4NTB1BgNVHSMEbjBsgBRa46Ix9s9tmMqu+Zz1mocHghm4
+NaFJpEcwRTELMAkGA1UEBhMCVVMxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNV
+BAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZIIJAO6wb0FSc/rNMAwGA1UdEwQF
+MAMBAf8wDQYJKoZIhvcNAQELBQADggEBACdrnM8zb7abxAJsU5WLn1IR0f2+EFA7
+ezBEJBM4bn0IZrXuP5ThZ2wieJlshG0C16XN9+zifavHci+AtQwWsB0f/ppHdvWQ
+7wt7JN88w+j0DNIYEadRCjWxR3gRAXPgKu3sdyScKFq8MvB49A2EdXRmQSTIM6Fj
+teRbE+poxewFT0mhurf3xrtGiSALmv7uAzhRDqpYUzcUlbOGgkyFLYAOOdvZvei+
+mfXDi4HKYxgyv53JxBARMdajnCHXM7zQ6Tjc8j1HRtmDQ3XapUB559KfxfODGQq5
+zmeoZWU4duxcNXJM0Eiz1CJ39JoWwi8sqaGi/oskuyAh7YKyVTn8xa8=
+-----END CERTIFICATE-----

tests/certs/selfsigned.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAsy7Zb3p4yCEnUtPLwqeJrwj9u/ZmcFCrMAktFBx9hG6rY2r7
+mdB6BflhV5cUJXxnsNiDpYcxGhA8kry7pEork1vZ05DyZC9ulVlvxBouVShBcLLw
+dpaoTGqEvYtejv6x7ogwMXOjkWWb1WpOv4CVhpeXJ7O/d1uAiYgcUpTpPp4ONG49
+IAouBHq3h+o4nVvNfB0J8gaCtTsTZqi1Wt8WYs3XjxGJaKh//ealfRe1kuv40CWQ
+8gjaC8/1w9pHdom3Wi/RwfDM3+dVGV6M5lAbPXMB4RK17Hk9P3hlJxJOpKBdgcBJ
+PXtNrTwfqEWWxk2mB/YVyB84AxjkkNoYyi2ggQIDAQABAoIBAFgVasxTf3aaXbNo
+7JzXMWb7W4iAG2GRNmZZzHA7hTSKFvS7jc3SX3n6WvDtEvlOi8ay2RyRNgEjBDP6
+VZ/w2jUJjS5k7dN0Qb9nhPr5B9fS/0CAppcVfsx5/KEVFzniWOPyzQYyW7FJKu8h
+4G5hrp/Ie4UH5tKtB6YUZB/wliyyQUkAZdBcoy1hfkOZLAXb1oofArKsiQUHIRA5
+th1yyS4cZP8Upngd1EE+d95dFHM2F6iI2lj6DHuu+JxUZ+wKXoNimdG7JniRtIf4
+56GoDov83Ey+XbIS6FSQc9nY0ijBDcubl/yP3roCQpE+MZ9BNEo5uj7YmCtAMYLW
+TXTNBGUCgYEA4wdkH1NLdub2NcpqwmSA0AtbRvDkt0XTDWWwmuMr/+xPVa4sUKHs
+80THQEX/WAZroP6IPbMP6BJhzb53vECukgC65qPxu6M9D1lBGtglxgen4AMu1bKK
+gnM8onwARGIo/2ay6qRRZZCxg0TvBky3hbTcIM2zVrnKU6VVyGKHSV8CgYEAygxs
+WQYrACv3XN6ZEzyxy08JgjbcnkPWK/m3VPcyHgdEkDu8+nDdUVdbF/js2JWMMx5g
+vrPhZ7jVLOXGcLr5mVU4dG5tW5lU0bMy+YYxpEQDiBKlpXgfOsQnakHj7cCZ6bay
+mKjJck2oEAQS9bqOJN/Ts5vhOmc8rmhkO7hnAh8CgYEArhVDy9Vl/1WYo6SD+m1w
+bJbYtewPpQzwicxZAFuDqKk+KDf3GRkhBWTO2FUUOB4sN3YVaCI+5zf5MPeE/qAm
+fCP9LM+3k6bXMkbBamEljdTfACHQruJJ3T+Z1gn5dnZCc5z/QncfRx8NTtfz5MO8
+0dTeGnVAuBacs0kLHy2WCUcCgYALNBkl7pOf1NBIlAdE686oCV/rmoMtO3G6yoQB
+8BsVUy3YGZfnAy8ifYeNkr3/XHuDsiGHMY5EJBmd/be9NID2oaUZv63MsHnljtw6
+vdgu1Z6kgvQwcrK4nXvaBoFPA6kFLp5EnMde0TOKf89VVNzg6pBgmzon9OWGfj9g
+mF8N3QKBgQCeoLwxUxpzEA0CPHm7DWF0LefVGllgZ23Eqncdy0QRku5zwwibszbL
+sWaR3uDCc3oYcbSGCDVx3cSkvMAJNalc5ZHPfoV9W0+v392/rrExo5iwD8CSoCb2
+gFWkeR7PBrD3NzFzFAWyiudzhBKHfRsB0MpCXbJV/WLqTlGIbEypjg==
+-----END RSA PRIVATE KEY-----

tests/static/decode me.txt

@@ -1 +1 @@
-I need to be decoded as a uri
+I am just a regular static file that needs to have its uri decoded

tests/test_bad_request.py

@@ -5,6 +5,7 @@ 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
@@ -15,6 +16,6 @@ def test_bad_request_response():
                 break
             lines.append(line)
         app.stop()
-    app.run(host='127.0.0.1', port=42101, debug=False, after_start=_request)
+    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,9 +1,9 @@
+import asyncio
 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
 
 
@@ -20,10 +20,37 @@ def test_bp():
         return text('Hello')
 
     app.blueprint(bp)
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'Hello'
 
+def test_bp_strict_slash():
+    app = Sanic('test_route_strict_slash')
+    bp = Blueprint('test_text')
+
+    @bp.get('/get', strict_slashes=True)
+    def handler(request):
+        return text('OK')
+
+    @bp.post('/post/', strict_slashes=True)
+    def handler(request):
+        return text('OK')
+
+    app.blueprint(bp)
+
+    request, response = app.test_client.get('/get')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/get/')
+    assert response.status == 404
+
+    request, response = app.test_client.post('/post/')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/post')
+    assert response.status == 404
+
+
 def test_bp_with_url_prefix():
     app = Sanic('test_text')
     bp = Blueprint('test_text', url_prefix='/test1')
@@ -33,7 +60,7 @@ def test_bp_with_url_prefix():
         return text('Hello')
 
     app.blueprint(bp)
-    request, response = sanic_endpoint_test(app, uri='/test1/')
+    request, response = app.test_client.get('/test1/')
 
     assert response.text == 'Hello'
 
@@ -53,10 +80,10 @@ def test_several_bp_with_url_prefix():
 
     app.blueprint(bp)
     app.blueprint(bp2)
-    request, response = sanic_endpoint_test(app, uri='/test1/')
+    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():
@@ -73,13 +100,15 @@ def test_bp_with_host():
 
     app.blueprint(bp)
     headers = {"Host": "example.com"}
-    request, response = sanic_endpoint_test(app, uri='/test1/',
-                                            headers=headers)
+    request, response = app.test_client.get(
+        '/test1/',
+        headers=headers)
     assert response.text == 'Hello'
 
     headers = {"Host": "sub.example.com"}
-    request, response = sanic_endpoint_test(app, uri='/test1/',
-                                            headers=headers)
+    request, response = app.test_client.get(
+        '/test1/',
+        headers=headers)
 
     assert response.text == 'Hello subdomain!'
 
@@ -111,18 +140,21 @@ def test_several_bp_with_host():
 
     assert bp.host == "example.com"
     headers = {"Host": "example.com"}
-    request, response = sanic_endpoint_test(app, uri='/test/',
-                                            headers=headers)
+    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 = sanic_endpoint_test(app, uri='/test/',
-                                            headers=headers)
+    request, response = app.test_client.get(
+        '/test/',
+        headers=headers)
 
     assert response.text == 'Hello2'
-    request, response = sanic_endpoint_test(app, uri='/test/other/',
-                                            headers=headers)
+    request, response = app.test_client.get(
+        '/test/other/',
+        headers=headers)
     assert response.text == 'Hello3'
 
 def test_bp_middleware():
@@ -139,7 +171,7 @@ def test_bp_middleware():
 
     app.blueprint(blueprint)
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.status == 200
     assert response.text == 'OK'
@@ -166,15 +198,15 @@ def test_bp_exception_handler():
 
     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')
+    request, response = app.test_client.get('/3')
     assert response.status == 200
 
 def test_bp_listeners():
@@ -209,7 +241,7 @@ def test_bp_listeners():
 
     app.blueprint(blueprint)
 
-    request, response = sanic_endpoint_test(app, uri='/')
+    request, response = app.test_client.get('/')
 
     assert order == [1,2,3,4,5,6]
 
@@ -225,13 +257,14 @@ def test_bp_static():
 
     app.blueprint(blueprint)
 
-    request, response = sanic_endpoint_test(app, uri='/testing.file')
+    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')
+    ev = asyncio.Event()
 
     @blueprint.get('/get')
     def handler(request):
@@ -261,46 +294,58 @@ def test_bp_shorthand():
     def handler(request):
         return text('OK')
 
+    @blueprint.websocket('/ws')
+    async def handler(request, ws):
+        ev.set()
+
     app.blueprint(blueprint)
 
-    request, response = sanic_endpoint_test(app, uri='/get', method='get')
+    request, response = app.test_client.get('/get')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/get', method='post')
+    request, response = app.test_client.post('/get')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/put', method='put')
+    request, response = app.test_client.put('/put')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/put', method='get')
+    request, response = app.test_client.get('/post')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/post', method='post')
+    request, response = app.test_client.post('/post')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/post', method='get')
+    request, response = app.test_client.get('/post')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/head', method='head')
+    request, response = app.test_client.head('/head')
     assert response.status == 200
 
-    request, response = sanic_endpoint_test(app, uri='/head', method='get')
+    request, response = app.test_client.get('/head')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/options', method='options')
+    request, response = app.test_client.options('/options')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/options', method='get')
+    request, response = app.test_client.get('/options')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/patch', method='patch')
+    request, response = app.test_client.patch('/patch')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/patch', method='get')
+    request, response = app.test_client.get('/patch')
     assert response.status == 405
 
-    request, response = sanic_endpoint_test(app, uri='/delete', method='delete')
+    request, response = app.test_client.delete('/delete')
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/delete', method='get')
+    request, response = app.test_client.get('/delete')
     assert response.status == 405
+
+    request, response = app.test_client.get('/ws', headers={
+        'Upgrade': 'websocket',
+        'Connection': 'upgrade',
+        'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==',
+        'Sec-WebSocket-Version': '13'})
+    assert response.status == 101
+    assert ev.is_set()

tests/test_config.py

@@ -16,6 +16,17 @@ def test_load_from_object():
     assert app.config.CONFIG_VALUE == 'should be used'
     assert 'not_for_config' not in app.config
 
+def test_auto_load_env():
+    environ["SANIC_TEST_ANSWER"] = "42"
+    app = Sanic()
+    assert app.config.TEST_ANSWER == "42"
+    del environ["SANIC_TEST_ANSWER"]
+
+def test_auto_load_env():
+    environ["SANIC_TEST_ANSWER"] = "42"
+    app = Sanic(load_env=False)
+    assert getattr(app.config, 'TEST_ANSWER', None) == None
+    del environ["SANIC_TEST_ANSWER"]
 
 def test_load_from_file():
     app = Sanic('test_load_from_file')

tests/test_cookies.py

@@ -2,7 +2,6 @@ from datetime import datetime, timedelta
 from http.cookies import SimpleCookie
 from sanic import Sanic
 from sanic.response import json, text
-from sanic.utils import sanic_endpoint_test
 import pytest
 
 
@@ -19,7 +18,7 @@ def test_cookies():
         response.cookies['right_back'] = 'at you'
         return response
 
-    request, response = sanic_endpoint_test(app, cookies={"test": "working!"})
+    request, response = app.test_client.get('/', cookies={"test": "working!"})
     response_cookies = SimpleCookie()
     response_cookies.load(response.headers.get('Set-Cookie', {}))
 
@@ -40,7 +39,7 @@ def test_false_cookies(httponly, expected):
         response.cookies['right_back']['httponly'] = httponly
         return response
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
     response_cookies = SimpleCookie()
     response_cookies.load(response.headers.get('Set-Cookie', {}))
 
@@ -55,7 +54,7 @@ def test_http2_cookies():
         return response
 
     headers = {'cookie': 'test=working!'}
-    request, response = sanic_endpoint_test(app, headers=headers)
+    request, response = app.test_client.get('/', headers=headers)
 
     assert response.text == 'Cookies are: working!'
 
@@ -70,7 +69,7 @@ def test_cookie_options():
         response.cookies['test']['expires'] = datetime.now() + timedelta(seconds=10)
         return response
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
     response_cookies = SimpleCookie()
     response_cookies.load(response.headers.get('Set-Cookie', {}))
 
@@ -88,7 +87,7 @@ def test_cookie_deletion():
         del response.cookies['i_never_existed']
         return response
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
     response_cookies = SimpleCookie()
     response_cookies.load(response.headers.get('Set-Cookie', {}))
 

tests/test_create_task.py

@@ -0,0 +1,30 @@
+from sanic import Sanic
+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('test_create_task')
+    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 = app.test_client.get('/early')
+    assert response.body == b'False'
+
+    request, response = app.test_client.get('/late')
+    assert response.body == b'True'