Merge pull request #878 from seemethere/increment_060

Increment to 0.6.0

.gitignore

@@ -14,3 +14,4 @@ settings.py
 docs/_build/
 docs/_api/
 build/*
+.DS_Store

.travis.yml

@@ -1,10 +1,25 @@
 sudo: false
+dist: precise
 language: python
-python:
-- '3.5'
-- '3.6'
-install: pip install tox-travis
-script: tox
+cache:
+  directories:
+    - $HOME/.cache/pip
+matrix:
+  include:
+    - env: TOX_ENV=py35
+      python: 3.5
+    - env: TOX_ENV=py35-no-ext
+      python: 3.5
+    - env: TOX_ENV=py36
+      python: 3.6
+    - env: TOX_ENV=py36-no-ext
+      python: 3.6
+    - env: TOX_ENV=flake8
+      python: 3.6
+    - env: TOX_ENV=check
+      python: 3.6
+install: pip install -U tox
+script: tox -e $TOX_ENV
 deploy:
   provider: pypi
   user: channelcat
@@ -12,3 +27,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"

CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sanic-maintainers@googlegroups.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,72 @@
+# 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.
+
+We are committed to providing a friendly, safe and welcoming environment for all,
+regardless of gender, sexual orientation, disability, ethnicity, religion,
+or similar personal characteristic.
+Our [code of conduct](./CONDUCT.md) sets the standards for behavior.
+
+## 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. All pull requests must be consistent with the existing code.
+5. If you decide to remove/change anything from any common interface
+a deprecation message should accompany it.
+6. If you implement a new feature you should have at least one unit
+test to accompany it.
+7. An example must be one of the following:
+  * Example of how to use Sanic
+  * Example of how to use Sanic extensions
+  * Example of how to use Sanic and asynchronous library
+
+## 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,33 +9,7 @@ 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!
 
-Benchmarks
-----------
-
-All tests were run on an AWS medium instance running ubuntu, using 1
-process. Each script delivered a small JSON response and was tested with
-wrk using 100 connections. Pypy was tested for Falcon and Flask but did
-not speed up requests.
-
-+-----------+-----------------------+----------------+---------------+
-| Server    | Implementation        | Requests/sec   | Avg Latency   |
-+===========+=======================+================+===============+
-| Sanic     | Python 3.5 + uvloop   | 33,342         | 2.96ms        |
-+-----------+-----------------------+----------------+---------------+
-| Wheezy    | gunicorn + meinheld   | 20,244         | 4.94ms        |
-+-----------+-----------------------+----------------+---------------+
-| Falcon    | gunicorn + meinheld   | 18,972         | 5.27ms        |
-+-----------+-----------------------+----------------+---------------+
-| Bottle    | gunicorn + meinheld   | 13,596         | 7.36ms        |
-+-----------+-----------------------+----------------+---------------+
-| Flask     | gunicorn + meinheld   | 4,988          | 20.08ms       |
-+-----------+-----------------------+----------------+---------------+
-| Kyoukai   | Python 3.5 + uvloop   | 3,889          | 27.44ms       |
-+-----------+-----------------------+----------------+---------------+
-| Aiohttp   | Python 3.5 + uvloop   | 2,979          | 33.42ms       |
-+-----------+-----------------------+----------------+---------------+
-| Tornado   | Python 3.5            | 2,138          | 46.66ms       |
-+-----------+-----------------------+----------------+---------------+
+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!
 
 Hello World Example
 -------------------
@@ -59,6 +33,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
 -------------
 
@@ -74,11 +55,21 @@ Documentation
    :target: https://pypi.python.org/pypi/sanic/
 .. |PyPI version| image:: https://img.shields.io/pypi/pyversions/sanic.svg
    :target: https://pypi.python.org/pypi/sanic/
+   
+
+Examples
+--------
+`Non-Core examples <https://github.com/channelcat/sanic/wiki/Examples/>`_. Examples of plugins and Sanic that are outside the scope of Sanic core.
+
+`Extensions <https://github.com/channelcat/sanic/wiki/Extensions/>`_. Sanic extensions created by the community.
+
+`Projects <https://github.com/channelcat/sanic/wiki/Projects/>`_. Sanic in production use.
+
 
 TODO
 ----
-* Streamed file processing
-* http2
+ * http2
+
 Limitations
 -----------
 * No wheels for uvloop and httptools on Windows :(

docs/Makefile

@@ -1,20 +1,225 @@
-# Minimal makefile for Sphinx documentation
+# Makefile for Sphinx documentation
 #
 
 # You can set these variables from the command line.
 SPHINXOPTS    =
 SPHINXBUILD   = sphinx-build
-SPHINXPROJ    = Sanic
-SOURCEDIR     = .
+PAPER         =
 BUILDDIR      = _build
 
-# Put it first so that "make" without argument is like "make help".
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help
 help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
 
-.PHONY: help Makefile
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)/*
 
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+.PHONY: html
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+.PHONY: dirhtml
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: pickle
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/aiographite.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/aiographite.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/aiographite"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/aiographite"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."

docs/conf.py

@@ -13,6 +13,9 @@ import sys
 # Add support for Markdown documentation using Recommonmark
 from recommonmark.parser import CommonMarkParser
 
+# Add support for auto-doc
+from recommonmark.transform import AutoStructify
+
 # Ensure that sanic is present in the path, to allow sphinx-apidoc to
 # autogenerate documentation from docstrings
 root_directory = os.path.dirname(os.getcwd())
@@ -22,7 +25,7 @@ import sanic
 
 # -- General configuration ------------------------------------------------
 
-extensions = []
+extensions = ['sphinx.ext.autodoc']
 
 templates_path = ['_templates']
 
@@ -68,7 +71,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 +82,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 +110,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 +125,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 +140,15 @@ 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']
+
+
+# app setup hook
+def setup(app):
+    app.add_config_value('recommonmark_config', {
+        'enable_eval_rst': True,
+        'enable_auto_doc_ref': True,
+    }, True)
+    app.add_transform(AutoStructify)

docs/index.rst

@@ -9,19 +9,24 @@ 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/decorators
+   sanic/streaming
    sanic/class_based_views
    sanic/custom_protocol
    sanic/ssl
+   sanic/logging
    sanic/testing
    sanic/deploying
    sanic/extensions
    sanic/contributing
+   sanic/api_reference
 
 
 Module Documentation
@@ -30,4 +35,5 @@ Module Documentation
 .. toctree::
 
 * :ref:`genindex`
+* :ref:`modindex`
 * :ref:`search`

docs/make.bat

@@ -1,19 +1,64 @@
 @ECHO OFF
 
-pushd %~dp0
-
 REM Command file for Sphinx documentation
 
 if "%SPHINXBUILD%" == "" (
 	set SPHINXBUILD=sphinx-build
 )
-set SOURCEDIR=.
 set BUILDDIR=_build
-set SPHINXPROJ=Sanic
+set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
+set I18NSPHINXOPTS=%SPHINXOPTS% .
+if NOT "%PAPER%" == "" (
+	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
+)
 
 if "%1" == "" goto help
 
-%SPHINXBUILD% >NUL 2>NUL
+if "%1" == "help" (
+	:help
+	echo.Please use `make ^<target^>` where ^<target^> is one of
+	echo.  html       to make standalone HTML files
+	echo.  dirhtml    to make HTML files named index.html in directories
+	echo.  singlehtml to make a single large HTML file
+	echo.  pickle     to make pickle files
+	echo.  json       to make JSON files
+	echo.  htmlhelp   to make HTML files and a HTML help project
+	echo.  qthelp     to make HTML files and a qthelp project
+	echo.  devhelp    to make HTML files and a Devhelp project
+	echo.  epub       to make an epub
+	echo.  epub3      to make an epub3
+	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  text       to make text files
+	echo.  man        to make manual pages
+	echo.  texinfo    to make Texinfo files
+	echo.  gettext    to make PO message catalogs
+	echo.  changes    to make an overview over all changed/added/deprecated items
+	echo.  xml        to make Docutils-native XML files
+	echo.  pseudoxml  to make pseudoxml-XML files for display purposes
+	echo.  linkcheck  to check all external links for integrity
+	echo.  doctest    to run all doctests embedded in the documentation if enabled
+	echo.  coverage   to run coverage check of the documentation if enabled
+	echo.  dummy      to check syntax errors of document sources
+	goto end
+)
+
+if "%1" == "clean" (
+	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+	del /q /s %BUILDDIR%\*
+	goto end
+)
+
+
+REM Check if sphinx-build is available and fallback to Python version if any
+%SPHINXBUILD% 1>NUL 2>NUL
+if errorlevel 9009 goto sphinx_python
+goto sphinx_ok
+
+:sphinx_python
+
+set SPHINXBUILD=python -m sphinx.__init__
+%SPHINXBUILD% 2> nul
 if errorlevel 9009 (
 	echo.
 	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
@@ -26,11 +71,211 @@ if errorlevel 9009 (
 	exit /b 1
 )
 
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
+:sphinx_ok
 
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+if "%1" == "html" (
+	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+	goto end
+)
+
+if "%1" == "dirhtml" (
+	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+	goto end
+)
+
+if "%1" == "singlehtml" (
+	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+	goto end
+)
+
+if "%1" == "pickle" (
+	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the pickle files.
+	goto end
+)
+
+if "%1" == "json" (
+	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the JSON files.
+	goto end
+)
+
+if "%1" == "htmlhelp" (
+	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run HTML Help Workshop with the ^
+.hhp project file in %BUILDDIR%/htmlhelp.
+	goto end
+)
+
+if "%1" == "qthelp" (
+	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+.qhcp project file in %BUILDDIR%/qthelp, like this:
+	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\aiographite.qhcp
+	echo.To view the help file:
+	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\aiographite.ghc
+	goto end
+)
+
+if "%1" == "devhelp" (
+	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished.
+	goto end
+)
+
+if "%1" == "epub" (
+	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub file is in %BUILDDIR%/epub.
+	goto end
+)
+
+if "%1" == "epub3" (
+	%SPHINXBUILD% -b epub3 %ALLSPHINXOPTS% %BUILDDIR%/epub3
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub3 file is in %BUILDDIR%/epub3.
+	goto end
+)
+
+if "%1" == "latex" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "latexpdf" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	cd %BUILDDIR%/latex
+	make all-pdf
+	cd %~dp0
+	echo.
+	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "latexpdfja" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	cd %BUILDDIR%/latex
+	make all-pdf-ja
+	cd %~dp0
+	echo.
+	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "text" (
+	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The text files are in %BUILDDIR%/text.
+	goto end
+)
+
+if "%1" == "man" (
+	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The manual pages are in %BUILDDIR%/man.
+	goto end
+)
+
+if "%1" == "texinfo" (
+	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
+	goto end
+)
+
+if "%1" == "gettext" (
+	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
+	goto end
+)
+
+if "%1" == "changes" (
+	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.The overview file is in %BUILDDIR%/changes.
+	goto end
+)
+
+if "%1" == "linkcheck" (
+	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Link check complete; look for any errors in the above output ^
+or in %BUILDDIR%/linkcheck/output.txt.
+	goto end
+)
+
+if "%1" == "doctest" (
+	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of doctests in the sources finished, look at the ^
+results in %BUILDDIR%/doctest/output.txt.
+	goto end
+)
+
+if "%1" == "coverage" (
+	%SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of coverage in the sources finished, look at the ^
+results in %BUILDDIR%/coverage/python.txt.
+	goto end
+)
+
+if "%1" == "xml" (
+	%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The XML files are in %BUILDDIR%/xml.
+	goto end
+)
+
+if "%1" == "pseudoxml" (
+	%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.
+	goto end
+)
+
+if "%1" == "dummy" (
+	%SPHINXBUILD% -b dummy %ALLSPHINXOPTS% %BUILDDIR%/dummy
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. Dummy builder generates no files.
+	goto end
+)
 
 :end
-popd

docs/sanic/api_reference.rst

@@ -0,0 +1,150 @@
+API Reference
+=============
+
+Submodules
+----------
+
+sanic.app module
+----------------
+
+.. automodule:: sanic.app
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.blueprints module
+-----------------------
+
+.. automodule:: sanic.blueprints
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.config module
+-------------------
+
+.. automodule:: sanic.config
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.constants module
+----------------------
+
+.. automodule:: sanic.constants
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.cookies module
+--------------------
+
+.. automodule:: sanic.cookies
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.exceptions module
+-----------------------
+
+.. automodule:: sanic.exceptions
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.handlers module
+---------------------
+
+.. automodule:: sanic.handlers
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.log module
+----------------
+
+.. automodule:: sanic.log
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.request module
+--------------------
+
+.. automodule:: sanic.request
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.response module
+---------------------
+
+.. automodule:: sanic.response
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.router module
+-------------------
+
+.. automodule:: sanic.router
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.server module
+-------------------
+
+.. automodule:: sanic.server
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.static module
+-------------------
+
+.. automodule:: sanic.static
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.testing module
+--------------------
+
+.. automodule:: sanic.testing
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.views module
+------------------
+
+.. automodule:: sanic.views
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.websocket module
+----------------------
+
+.. automodule:: sanic.websocket
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+sanic.worker module
+-------------------
+
+.. automodule:: sanic.worker
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: sanic
+    :members:
+    :undoc-members:
+    :show-inheritance:

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()
@@ -137,7 +142,7 @@ 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')
@@ -164,7 +169,7 @@ app.run(host='0.0.0.0', port=8000, debug=True)
 If you wish to generate a URL for a route inside of a blueprint, remember that the endpoint name
 takes the format `<blueprint_name>.<handler_name>`. For example:
 
-```
+```python
 @blueprint_v1.route('/')
 async def root(request):
     url = app.url_for('v1.post_handler', post_id=5) # --> '/v1/post/5'

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_env` boolean to the Sanic constructor to override that:
+
+```python
+app = Sanic(load_env=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:
@@ -44,7 +52,7 @@ You could use a class or any other object as well.
 
 ### From a File
 
-Usually you will want to load configuration from a file that is not part of the distributed application. You can load configuration from a file using `from_file(/path/to/config_file)`. However, that requires the program to know the path to the config file. So instead you can specify the location of the config file in an environment variable and tell Sanic to use that to find the config file:
+Usually you will want to load configuration from a file that is not part of the distributed application. You can load configuration from a file using `from_pyfile(/path/to/config_file)`. However, that requires the program to know the path to the config file. So instead you can specify the location of the config file in an environment variable and tell Sanic to use that to find the config file:
 
 ```
 app = Sanic('myapp')
@@ -58,7 +66,7 @@ $ MYAPP_SETTINGS=/path/to/config_file python3 myapp.py
 INFO: Goin' Fast @ http://0.0.0.0:8000
 ```
 
-The config files are regular Python files which are executed in order to load them. This allows you to use arbitrary logic for constructing the right configuration. Only uppercase varibales are added to the configuration. Most commonly the configuration consists of simple key value pairs:
+The config files are regular Python files which are executed in order to load them. This allows you to use arbitrary logic for constructing the right configuration. Only uppercase variables are added to the configuration. Most commonly the configuration consists of simple key value pairs:
 
 ```
 # config_file
@@ -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

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

docs/sanic/cookies.rst

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

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

@@ -44,3 +44,35 @@ 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 myapp:app --bind 0.0.0.0:1337 --worker-class sanic.worker.GunicornWorker
+```
+
+If your application suffers from memory leaks, you can configure Gunicorn to gracefully restart a worker
+after it has processed a given number of requests. This can be a convenient way to help limit the effects
+of the memory leak.
+
+See the [Gunicorn Docs](http://docs.gunicorn.org/en/latest/settings.html#max-requests) for more information.
+
+## 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/exceptions.md

@@ -17,6 +17,19 @@ def i_am_ready_to_die(request):
 	raise ServerError("Something bad happened", status_code=500)
 ```
 
+You can also use the `abort` function with the appropriate status code:
+
+```python
+from sanic.exceptions import abort
+from sanic.response import text
+
+@app.route('/youshallnotpass')
+def no_no(request):
+        abort(401)
+        # this won't happen
+        text("OK")
+```
+
 ## Handling exceptions
 
 To override Sanic's default handling of an exception, the `@app.exception`

docs/sanic/extensions.md

@@ -12,3 +12,16 @@ A list of Sanic extensions created by the community.
 - [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.
+- [sanic-transmute](https://github.com/yunstanford/sanic-transmute): A Sanic extension that generates APIs from python function and classes, and also generates Swagger UI/documentation automatically.
+- [pytest-sanic](https://github.com/yunstanford/pytest-sanic): A pytest plugin for Sanic. It helps you to test your code asynchronously.
+- [jinja2-sanic](https://github.com/yunstanford/jinja2-sanic): a jinja2 template renderer for Sanic.([Documentation](http://jinja2-sanic.readthedocs.io/en/latest/))

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,119 @@
+# 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 to create a new configuration.
+
+### Quick Start
+
+A simple example using default settings 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'] = [
+    'accessSysLog', 'errorSysLog']
+
+app = Sanic('test')
+
+@app.route('/')
+async def test(request):
+    return response.text('Hello World!')
+
+if __name__ == "__main__":
+  app.run(log_config=LOGGING)
+```
+
+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)
+
+
+And `filters`:
+
+- accessFilter (using sanic.log.DefaultFilter)<br>
+  The filter that allows only levels in `DEBUG`, `INFO`, and `NONE(0)`
+
+
+- errorFilter (using sanic.log.DefaultFilter)<br>
+  The filter that 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,15 +62,15 @@ 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.
@@ -85,6 +89,13 @@ The following variables are accessible as properties on `Request` objects:
           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`
 

docs/sanic/response.md

@@ -0,0 +1,112 @@
+# 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')
+```
+
+## File Streaming
+For large files, a combination of File and Streaming above
+```python
+from sanic import response
+
+@app.route('/big_file.png')
+async def handle_request(request):
+    return await response.file_stream('/srv/www/whatever.png')
+```
+
+## 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

@@ -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))
 
@@ -181,3 +181,36 @@ url = app.url_for('post_handler', post_id=5, arg_one=['one', 'two'], arg_two=2,
 # 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,106 @@
+# Streaming
+
+## Request Streaming
+
+Sanic allows you to get request data by stream, as below. When the request ends, `request.stream.get()` returns `None`. Only post, put and patch decorator have stream argument.
+
+```python
+from sanic import Sanic
+from sanic.views import CompositionView
+from sanic.views import HTTPMethodView
+from sanic.views import stream as stream_decorator
+from sanic.blueprints import Blueprint
+from sanic.response import stream, text
+
+bp = Blueprint('blueprint_request_stream')
+app = Sanic('request_stream')
+
+
+class SimpleView(HTTPMethodView):
+
+    @stream_decorator
+    async def post(self, request):
+        result = ''
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            result += body.decode('utf-8')
+        return text(result)
+
+
+@app.post('/stream', stream=True)
+async def handler(request):
+    async def streaming(response):
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            body = body.decode('utf-8').replace('1', 'A')
+            response.write(body)
+    return stream(streaming)
+
+
+@bp.put('/bp_stream', stream=True)
+async def bp_handler(request):
+    result = ''
+    while True:
+        body = await request.stream.get()
+        if body is None:
+            break
+        result += body.decode('utf-8').replace('1', 'A')
+    return text(result)
+
+
+async def post_handler(request):
+    result = ''
+    while True:
+        body = await request.stream.get()
+        if body is None:
+            break
+        result += body.decode('utf-8')
+    return text(result)
+
+app.blueprint(bp)
+app.add_route(SimpleView.as_view(), '/method_view')
+view = CompositionView()
+view.add(['POST'], post_handler, stream=True)
+app.add_route(view, '/composition_view')
+
+
+if __name__ == '__main__':
+    app.run(host='127.0.0.1', port=8000)
+```
+
+## Response 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

@@ -59,15 +59,69 @@ the available arguments to aiohttp can be found
 [in the documentation for ClientSession](https://aiohttp.readthedocs.io/en/stable/client_reference.html#client-session).
 
 
-### Deprecated: `sanic_endpoint_test`
+## pytest-sanic
 
-Prior to version 0.3.2, testing was provided through the `sanic_endpoint_test` method. This method will be deprecated in the next major version after 0.4.0; please use the `test_client` instead.
+[pytest-sanic](https://github.com/yunstanford/pytest-sanic) is a pytest plugin, it helps you to test your code asynchronously.
+Just write tests like,
 
-```
-from sanic.utils import sanic_endpoint_test
-
-def test_index_returns_200():
-    request, response = sanic_endpoint_test(app)
-    assert response.status == 200
+```python
+async def test_sanic_db_find_by_id(app):
+    """
+    Let's assume that, in db we have,
+        {
+            "id": "123",
+            "name": "Kobe Bryant",
+            "team": "Lakers",
+        }
+    """
+    doc = await app.db["players"].find_by_id("123")
+    assert doc.name == "Kobe Bryant"
+    assert doc.team == "Lakers"
 ```
 
+[pytest-sanic](https://github.com/yunstanford/pytest-sanic) also provides some useful fixtures, like loop, unused_port,
+test_server, test_client.
+
+```python
+@pytest.yield_fixture
+def app():
+    app = Sanic("test_sanic_app")
+
+    @app.route("/test_get", methods=['GET'])
+    async def test_get(request):
+        return response.json({"GET": True})
+
+    @app.route("/test_post", methods=['POST'])
+    async def test_post(request):
+        return response.json({"POST": True})
+
+    yield app
+
+
+@pytest.fixture
+def test_cli(loop, app, test_client):
+    return loop.run_until_complete(test_client(app, protocol=WebSocketProtocol))
+
+
+#########
+# Tests #
+#########
+
+async def test_fixture_test_client_get(test_cli):
+    """
+    GET request
+    """
+    resp = await test_cli.get('/test_get')
+    assert resp.status == 200
+    resp_json = await resp.json()
+    assert resp_json == {"GET": True}
+
+async def test_fixture_test_client_post(test_cli):
+    """
+    POST request
+    """
+    resp = await test_cli.post('/test_post')
+    assert resp.status == 200
+    resp_json = await resp.json()
+    assert resp_json == {"POST": True}
+```

docs/sanic/versioning.md

@@ -0,0 +1,50 @@
+# Versioning
+
+You can pass the `version` keyword to the route decorators, or to a blueprint initializer. It will result in the `v{version}` url prefix where `{version}` is the version number.
+
+## Per route
+
+You can pass a version number to the routes directly.
+
+```python
+from sanic import response
+
+
+@app.route('/text', version=1)
+def handle_request(request):
+    return response.text('Hello world! Version 1')
+
+@app.route('/text', version=2)
+def handle_request(request):
+    return response.text('Hello world! Version 2')
+
+app.run(port=80)
+```
+
+Then with curl:
+
+```bash
+curl localhost/v1/text
+curl localhost/v2/text
+```
+
+## Global blueprint version
+
+You can also pass a version number to the blueprint, which will apply to all routes.
+
+```python
+from sanic import response
+from sanic.blueprints import Blueprint
+
+bp = Blueprint('test', version=1)
+
+@bp.route('/html')
+def handle_request(request):
+    return response.html('<p>Hello world!</p>')
+```
+
+Then with curl:
+
+```bash
+curl localhost/v1/html
+```

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

examples/blueprints.py

@@ -1,11 +1,12 @@
 from sanic import Sanic
 from sanic import Blueprint
-from sanic.response import json, text
+from sanic.response import json
 
 
 app = Sanic(__name__)
 blueprint = Blueprint('name', url_prefix='/my_blueprint')
-blueprint2 = Blueprint('name', url_prefix='/my_blueprint2')
+blueprint2 = Blueprint('name2', url_prefix='/my_blueprint2')
+blueprint3 = Blueprint('name3', url_prefix='/my_blueprint3')
 
 
 @blueprint.route('/foo')
@@ -18,7 +19,17 @@ async def foo2(request):
     return json({'msg': 'hi from blueprint2'})
 
 
-app.register_blueprint(blueprint)
-app.register_blueprint(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.blueprint(blueprint)
+app.blueprint(blueprint2)
+app.blueprint(blueprint3)
 
 app.run(host="0.0.0.0", port=8000, debug=True)

examples/cache_example.py

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

examples/exception_monitoring.py

@@ -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,10 @@ server's error_handler to an instance of our CustomHandler
 """
 
 from sanic import Sanic
-from sanic.response import json
 
 app = Sanic(__name__)
 
-handler = CustomHandler(sanic=app)
+handler = CustomHandler()
 app.error_handler = handler
 
 
@@ -50,8 +48,7 @@ app.error_handler = handler
 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})
+    raise SanicException('You Broke It!')
 
-
-app.run(host="0.0.0.0", port=8000, debug=True)
+if __name__ == '__main__':
+    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/limit_concurrency.py

@@ -8,11 +8,12 @@ app = Sanic(__name__)
 
 sem = None
 
+
 @app.listener('before_server_start')
 def init(sanic, loop):
     global sem
-    CONCURRENCY_PER_WORKER = 4
-    sem = asyncio.Semaphore(CONCURRENCY_PER_WORKER, loop=loop)
+    concurrency_per_worker = 4
+    sem = asyncio.Semaphore(concurrency_per_worker, loop=loop)
 
 async def bounded_fetch(session, url):
     """

examples/modify_header_example.py

@@ -0,0 +1,28 @@
+"""
+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 "
@@ -15,9 +14,11 @@ log = logging.getLogger()
 
 # Set logger to override default basicConfig
 sanic = Sanic()
+
+
 @sanic.route("/")
 def test(request):
     log.info("received request; responding with 'hey'")
-    return text("hey")
+    return response.text("hey")
 
 sanic.run(host="0.0.0.0", port=8000)

examples/redirect_example.py

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

@@ -0,0 +1,10 @@
+import requests
+
+# Warning: This is a heavy process.
+
+data = ""
+for i in range(1, 250000):
+    data += str(i)
+
+r = requests.post('http://0.0.0.0:8000/stream', data=data)
+print(r.text)

examples/request_stream/server.py

@@ -0,0 +1,65 @@
+from sanic import Sanic
+from sanic.views import CompositionView
+from sanic.views import HTTPMethodView
+from sanic.views import stream as stream_decorator
+from sanic.blueprints import Blueprint
+from sanic.response import stream, text
+
+bp = Blueprint('blueprint_request_stream')
+app = Sanic('request_stream')
+
+
+class SimpleView(HTTPMethodView):
+
+    @stream_decorator
+    async def post(self, request):
+        result = ''
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            result += body.decode('utf-8')
+        return text(result)
+
+
+@app.post('/stream', stream=True)
+async def handler(request):
+    async def streaming(response):
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            body = body.decode('utf-8').replace('1', 'A')
+            response.write(body)
+    return stream(streaming)
+
+
+@bp.put('/bp_stream', stream=True)
+async def bp_handler(request):
+    result = ''
+    while True:
+        body = await request.stream.get()
+        if body is None:
+            break
+        result += body.decode('utf-8').replace('1', 'A')
+    return text(result)
+
+
+async def post_handler(request):
+    result = ''
+    while True:
+        body = await request.stream.get()
+        if body is None:
+            break
+        result += body.decode('utf-8')
+    return text(result)
+
+app.blueprint(bp)
+app.add_route(SimpleView.as_view(), '/method_view')
+view = CompositionView()
+view.add(['POST'], post_handler, stream=True)
+app.add_route(view, '/composition_view')
+
+
+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)

examples/run_async.py

@@ -1,18 +1,18 @@
 from sanic import Sanic
-from sanic.response import json
-from multiprocessing import Event
+from sanic import response
 from signal import signal, SIGINT
 import asyncio
 import uvloop
 
 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_aiopg_example.py

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

examples/sanic_aiopg_sqlalchemy_example.py

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

examples/sanic_asyncpg_example.py

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

examples/sanic_motor.py

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

examples/sanic_peewee.py

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

examples/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

@@ -2,7 +2,7 @@ import os
 
 from sanic import Sanic
 from sanic.log import log
-from sanic.response import json, text, file
+from sanic import response
 from sanic.exceptions import ServerError
 
 app = Sanic(__name__)
@@ -10,41 +10,50 @@ 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))
+def test_params(request, name, i):
+    return response.text("yeehaww {} {}".format(name, i))
 
 
 @app.route("/exception")
 def exception(request):
     raise ServerError("It's dead jim")
 
+
 @app.route("/await")
 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 file(os.path.abspath("setup.py"))
+    return await response.file(os.path.abspath("setup.py"))
 
 
+@app.route("/file_stream")
+async def test_file_stream(request):
+    return await response.file_stream(os.path.abspath("setup.py"),
+                                      chunk_size=1024)
+
 # ----------------------------------------------- #
 # Exceptions
 # ----------------------------------------------- #
 
+
 @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)
 
 
 # ----------------------------------------------- #
@@ -53,23 +62,29 @@ 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")
@@ -77,7 +92,13 @@ def after_start(app, loop):
 
 @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)
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000, debug=True)

examples/unix_socket.py

@@ -0,0 +1,23 @@
+from sanic import Sanic
+from sanic import response
+import socket
+import os
+
+app = Sanic(__name__)
+
+
+@app.route("/test")
+async def test(request):
+    return response.text("OK")
+
+if __name__ == '__main__':
+    server_address = './uds_socket'
+    # Make sure the socket does not already exist
+    try:
+            os.unlink(server_address)
+    except OSError:
+            if os.path.exists(server_address):
+                        raise
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(server_address)
+    app.run(sock=sock)

examples/url_for_example.py

@@ -0,0 +1,20 @@
+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
 
@@ -11,29 +11,29 @@ from sanic.blueprints import Blueprint
 app = Sanic()
 bp = Blueprint("bp", host="bp.example.com")
 
+
 @app.route('/', host=["example.com",
                       "somethingelse.com",
                       "therestofyourdomains.com"])
 async def hello(request):
-    return text("Some defaults")
+    return response.text("Some defaults")
 
-@app.route('/', host="example.com")
-async def hello(request):
-    return text("Answer")
 
 @app.route('/', host="sub.example.com")
 async def hello(request):
-    return text("42")
+    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)
+app.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,24 @@
+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(host="0.0.0.0", port=8000, debug=True)
+

requirements-dev.txt

@@ -1,18 +1,12 @@
-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
+gunicorn

requirements-docs.txt

@@ -0,0 +1,3 @@
+sphinx
+sphinx_rtd_theme
+recommonmark

requirements.txt

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

sanic/__init__.py

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

sanic/__main__.py

@@ -8,6 +8,10 @@ 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

@@ -1,29 +1,36 @@
 import logging
+import logging.config
 import re
 import warnings
-from asyncio import get_event_loop
+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
+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
+from sanic.response import HTTPResponse, StreamingHTTPResponse
 from sanic.router import Router
-from sanic.server import serve, serve_multiple, HttpProtocol
+from sanic.server import serve, serve_multiple, HttpProtocol, Signal
 from sanic.static import register as static_register
-from sanic.testing import TestClient
+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):
+    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:
@@ -41,8 +48,10 @@ class Sanic:
 
         self.name = name
         self.router = router or Router()
+        self.request_class = request_class
         self.error_handler = error_handler or ErrorHandler()
-        self.config = Config()
+        self.config = Config(load_env=load_env)
+        self.log_config = log_config
         self.request_middleware = deque()
         self.response_middleware = deque()
         self.blueprints = {}
@@ -51,6 +60,9 @@ class Sanic:
         self.sock = None
         self.listeners = defaultdict(list)
         self.is_running = False
+        self.is_request_stream = False
+        self.websocket_enabled = False
+        self.websocket_tasks = []
 
         # Register alternative method names
         self.go_fast = self.run
@@ -98,12 +110,15 @@ class Sanic:
         return decorator
 
     # Decorator
-    def route(self, uri, methods=frozenset({'GET'}), host=None):
+    def route(self, uri, methods=frozenset({'GET'}), host=None,
+              strict_slashes=False, stream=False, version=None):
         """Decorate a function to be registered as a route
 
         :param uri: path of the URL
         :param methods: list or tuple of methods allowed
         :param host:
+        :param strict_slashes:
+        :param stream:
         :return: decorated function
         """
 
@@ -112,36 +127,56 @@ class Sanic:
         if not uri.startswith('/'):
             uri = '/' + uri
 
+        if stream:
+            self.is_request_stream = True
+
         def response(handler):
+            if stream:
+                handler.is_stream = stream
             self.router.add(uri=uri, methods=methods, handler=handler,
-                            host=host)
+                            host=host, strict_slashes=strict_slashes,
+                            version=version)
             return handler
 
         return response
 
     # Shorthand method decorators
-    def get(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"GET"}), host=host)
+    def get(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=frozenset({"GET"}), host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def post(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"POST"}), host=host)
+    def post(self, uri, host=None, strict_slashes=False, stream=False,
+             version=None):
+        return self.route(uri, methods=frozenset({"POST"}), host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def put(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"PUT"}), host=host)
+    def put(self, uri, host=None, strict_slashes=False, stream=False,
+            version=None):
+        return self.route(uri, methods=frozenset({"PUT"}), host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def head(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"HEAD"}), host=host)
+    def head(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=frozenset({"HEAD"}), host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def options(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"OPTIONS"}), host=host)
+    def options(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=frozenset({"OPTIONS"}), host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def patch(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"PATCH"}), host=host)
+    def patch(self, uri, host=None, strict_slashes=False, stream=False,
+              version=None):
+        return self.route(uri, methods=frozenset({"PATCH"}), host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def delete(self, uri, host=None):
-        return self.route(uri, methods=frozenset({"DELETE"}), host=host)
+    def delete(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=frozenset({"DELETE"}), host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None):
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None,
+                  strict_slashes=False, version=None):
         """A helper method to register class instance or
         functions as a handler to the application url
         routes.
@@ -153,21 +188,97 @@ class Sanic:
         :param host:
         :return: function or class instance
         """
+        stream = False
         # Handle HTTPMethodView differently
         if hasattr(handler, 'view_class'):
             methods = set()
 
             for method in HTTP_METHODS:
-                if getattr(handler.view_class, method.lower(), None):
+                _handler = getattr(handler.view_class, method.lower(), None)
+                if _handler:
                     methods.add(method)
+                    if hasattr(_handler, 'is_stream'):
+                        stream = True
 
         # handle composition view differently
         if isinstance(handler, CompositionView):
             methods = handler.handlers.keys()
+            for _handler in handler.handlers.values():
+                if hasattr(_handler, 'is_stream'):
+                    stream = True
+                    break
 
-        self.route(uri=uri, methods=methods, host=host)(handler)
+        self.route(uri=uri, methods=methods, host=host,
+                   strict_slashes=strict_slashes, stream=stream,
+                   version=version)(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
+                try:
+                    protocol = request.transport.get_protocol()
+                except AttributeError:
+                    # On Python3.5 the Transport classes in asyncio do not
+                    # have a get_protocol() method as in uvloop
+                    protocol = request.transport._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)
 
@@ -181,39 +292,46 @@ class Sanic:
 
         def response(handler):
             for exception in exceptions:
-                self.error_handler.add(exception, handler)
+                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
 
+    def register_middleware(self, middleware, attach_to='request'):
+        if attach_to == 'request':
+            self.request_middleware.append(middleware)
+        if attach_to == 'response':
+            self.response_middleware.appendleft(middleware)
+        return middleware
+
     # 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)
+            return self.register_middleware(middleware_or_request)
 
         else:
-            return partial(register_middleware,
+            return partial(self.register_middleware,
                            attach_to=middleware_or_request)
 
     # Static Files
-    def static(self, uri, file_or_directory, pattern='.+',
-               use_modified_since=True, use_content_range=False):
+    def static(self, uri, file_or_directory, pattern=r'/?.+',
+               use_modified_since=True, use_content_range=False,
+               stream_large_files=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)
+                        use_modified_since, use_content_range,
+                        stream_large_files)
 
     def blueprint(self, blueprint, **options):
         """Register a blueprint on the application.
@@ -254,7 +372,7 @@ class Sanic:
         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
+        :param \*\*kwargs: keys and values that are used to build request
             parameters and query string arguments.
 
         :return: the built URL
@@ -345,14 +463,17 @@ class Sanic:
     def converted_response_type(self, response):
         pass
 
-    async def handle_request(self, request, response_callback):
+    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 response_callback: Response function to be called with the
-                                  response as the only argument
+        :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:
@@ -361,17 +482,7 @@ class Sanic:
             # -------------------------------------------- #
 
             request.app = self
-
-            response = False
-            # The if improves speed.  I don't know why
-            if self.request_middleware:
-                for middleware in self.request_middleware:
-                    response = middleware(request)
-                    if isawaitable(response):
-                        response = await response
-                    if response:
-                        break
-
+            response = await self._run_request_middleware(request)
             # No middleware results
             if not response:
                 # -------------------------------------------- #
@@ -379,7 +490,8 @@ class Sanic:
                 # -------------------------------------------- #
 
                 # Fetch handler from router
-                handler, args, kwargs = self.router.get(request)
+                handler, args, kwargs, uri = self.router.get(request)
+                request.uri_template = uri
                 if handler is None:
                     raise ServerError(
                         ("'None' was returned while requesting a "
@@ -389,20 +501,6 @@ class Sanic:
                 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
@@ -420,8 +518,23 @@ class Sanic:
                 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'
+                )
 
-        response_callback(response)
+        # pass the response to the correct callback
+        if isinstance(response, StreamingHTTPResponse):
+            await stream_callback(response)
+        else:
+            write_callback(response)
 
     # -------------------------------------------------------------------- #
     # Testing
@@ -429,57 +542,63 @@ class Sanic:
 
     @property
     def test_client(self):
-        return TestClient(self)
+        return SanicTestClient(self)
 
     # -------------------------------------------------------------------- #
     # Execution
     # -------------------------------------------------------------------- #
 
-    def run(self, host="127.0.0.1", port=8000, debug=False, before_start=None,
-            after_start=None, before_stop=None, after_stop=None, ssl=None,
-            sock=None, workers=1, loop=None, protocol=HttpProtocol,
-            backlog=100, stop_event=None, register_sys_signals=True):
+    def run(self, host=None, port=None, debug=False, ssl=None,
+            sock=None, workers=1, protocol=None,
+            backlog=100, stop_event=None, register_sys_signals=True,
+            log_config=None):
         """Run the HTTP Server and listen until keyboard interrupt or term
         signal. On termination, drain connections before closing.
 
         :param host: Address to host on
         :param port: Port to host on
         :param debug: Enables debug output (slows server)
-        :param before_start: Functions to be executed before the server starts
-                             accepting connections
-        :param after_start: Functions to be executed after the server starts
-                            accepting connections
-        :param before_stop: Functions to be executed when a stop signal is
-                            received before it is respected
-        :param after_stop: Functions to be executed when all requests are
-                           complete
-        :param ssl: SSLContext for SSL encryption of worker(s)
+        :param 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 loop:
+                            received before it is respected
         :param backlog:
         :param stop_event:
         :param register_sys_signals:
         :param protocol: Subclass of asyncio protocol class
         :return: Nothing
         """
+        if sock is None:
+            host, port = host or "127.0.0.1", port or 8000
+
+        if log_config:
+            self.log_config = 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, 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)
+            host=host, port=port, debug=debug, ssl=ssl, sock=sock,
+            workers=workers, protocol=protocol, backlog=backlog,
+            register_sys_signals=register_sys_signals,
+            has_log=self.log_config is not None)
 
         try:
             self.is_running = True
             if workers == 1:
                 serve(**server_settings)
             else:
-                serve_multiple(server_settings, workers, stop_event)
+                serve_multiple(server_settings, workers)
         except:
             log.exception(
                 'Experienced exception while trying to serve')
+            raise
         finally:
             self.is_running = False
         log.info("Server Stopped")
@@ -488,49 +607,80 @@ class Sanic:
         """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):
+    def __call__(self):
+        """gunicorn compatibility"""
+        return self
+
+    async def create_server(self, host=None, port=None, 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 sock is None:
+            host, port = host or "127.0.0.1", port or 8000
+
+        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, before_start=before_start,
-            after_start=after_start, before_stop=before_stop,
-            after_stop=after_stop, ssl=ssl, sock=sock,
-            loop=loop or get_event_loop(), protocol=protocol,
-            backlog=backlog, stop_event=stop_event,
-            run_async=True)
+            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)
 
-    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,
+    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=None, port=None, debug=False,
+                ssl=None, sock=None, workers=1, loop=None,
                 protocol=HttpProtocol, backlog=100, stop_event=None,
-                register_sys_signals=True, run_async=False):
+                register_sys_signals=True, run_async=False, has_log=True):
         """Helper function used by `run` and `create_server`."""
-
-        if loop is not None:
+        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("Passing a loop will be deprecated in version"
-                          " 0.4.0 https://github.com/channelcat/sanic/"
-                          "pull/335 has more information.",
-                          DeprecationWarning)
-
-        # Deprecate this
-        if any(arg is not None for arg in (after_stop, after_start,
-                                           before_start, before_stop)):
-            if debug:
-                warnings.simplefilter('default')
-            warnings.warn("Passing a before_start, before_stop, after_start or"
-                          "after_stop callback will be deprecated in next "
-                          "major version after 0.4.0",
+            warnings.warn("stop_event will be removed from future versions.",
                           DeprecationWarning)
 
         self.error_handler.debug = debug
@@ -538,36 +688,40 @@ class Sanic:
 
         server_settings = {
             'protocol': protocol,
+            'request_class': self.request_class,
+            'is_request_stream': self.is_request_stream,
+            'router': self.router,
             '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
+            'backlog': backlog,
+            'has_log': has_log,
+            'websocket_max_size': self.config.WEBSOCKET_MAX_SIZE,
+            'websocket_max_queue': self.config.WEBSOCKET_MAX_QUEUE,
+            'graceful_shutdown_timeout': self.config.GRACEFUL_SHUTDOWN_TIMEOUT
         }
 
         # -------------------------------------------- #
         # Register start/stop events
         # -------------------------------------------- #
 
-        for event_name, settings_name, reverse, args in (
-                ("before_server_start", "before_start", False, before_start),
-                ("after_server_start", "after_start", False, after_start),
-                ("before_server_stop", "before_stop", True, before_stop),
-                ("after_server_stop", "after_stop", True, after_stop),
+        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 args:
-                if callable(args):
-                    listeners.append(args)
-                else:
-                    listeners.extend(args)
             if reverse:
                 listeners.reverse()
             # Prepend sanic to the arguments when listeners are triggered
@@ -583,9 +737,10 @@ class Sanic:
             server_settings['run_async'] = True
 
         # Serve
-        proto = "http"
-        if ssl is not None:
-            proto = "https"
-        log.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
+        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

@@ -3,7 +3,9 @@ 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', 'stream', 'version'])
 FutureListener = namedtuple('Listener', ['handler', 'uri', 'methods', 'host'])
 FutureMiddleware = namedtuple('Route', ['middleware', 'args', 'kwargs'])
 FutureException = namedtuple('Route', ['handler', 'args', 'kwargs'])
@@ -12,7 +14,7 @@ FutureStatic = namedtuple('Route',
 
 
 class Blueprint:
-    def __init__(self, name, url_prefix=None, host=None):
+    def __init__(self, name, url_prefix=None, host=None, version=None):
         """Create a new blueprint
 
         :param name: unique name of the blueprint
@@ -23,10 +25,12 @@ class Blueprint:
         self.host = host
 
         self.routes = []
+        self.websocket_routes = []
         self.exceptions = []
         self.listeners = defaultdict(list)
         self.middlewares = []
         self.statics = []
+        self.version = version
 
     def register(self, app, options):
         """Register the blueprint to the sanic app."""
@@ -40,19 +44,38 @@ class Blueprint:
             future.handler.__blueprintname__ = self.name
             # Prepend the blueprint URI prefix if available
             uri = url_prefix + future.uri if url_prefix else future.uri
+
+            version = future.version or self.version
+
             app.route(
                 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,
+                stream=future.stream,
+                version=version
+                )(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
         for future in self.middlewares:
             if future.args or future.kwargs:
-                app.middleware(*future.args,
-                               **future.kwargs)(future.middleware)
+                app.register_middleware(future.middleware,
+                                        *future.args,
+                                        **future.kwargs)
             else:
-                app.middleware(future.middleware)
+                app.register_middleware(future.middleware)
 
         # Exceptions
         for future in self.exceptions:
@@ -70,19 +93,22 @@ class Blueprint:
             for listener in listeners:
                 app.listener(event)(listener)
 
-    def route(self, uri, methods=frozenset({'GET'}), host=None):
+    def route(self, uri, methods=frozenset({'GET'}), host=None,
+              strict_slashes=False, stream=False, version=None):
         """Create a blueprint route from a decorated function.
 
         :param uri: endpoint at which the route will be accessible.
         :param methods: list of acceptable HTTP methods.
         """
         def decorator(handler):
-            route = FutureRoute(handler, uri, methods, host)
+            route = FutureRoute(
+                handler, uri, methods, host, strict_slashes, stream, version)
             self.routes.append(route)
             return handler
         return decorator
 
-    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None):
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None,
+                  strict_slashes=False, version=None):
         """Create a blueprint route from a function.
 
         :param handler: function for handling uri requests. Accepts function,
@@ -103,7 +129,31 @@ class Blueprint:
         if isinstance(handler, CompositionView):
             methods = handler.handlers.keys()
 
-        self.route(uri=uri, methods=methods, host=host)(handler)
+        self.route(uri=uri, methods=methods, host=host,
+                   strict_slashes=strict_slashes, version=version)(handler)
+        return handler
+
+    def websocket(self, uri, host=None, strict_slashes=False, version=None):
+        """Create a blueprint websocket route from a decorated function.
+
+        :param uri: endpoint at which the route will be accessible.
+        """
+        def decorator(handler):
+            route = FutureRoute(handler, uri, [], host, strict_slashes,
+                                False, version)
+            self.websocket_routes.append(route)
+            return handler
+        return decorator
+
+    def add_websocket_route(self, handler, uri, host=None, version=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, version=version)(handler)
         return handler
 
     def listener(self, event):
@@ -149,23 +199,36 @@ class Blueprint:
         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, version=None):
+        return self.route(uri, methods=["GET"], host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def post(self, uri, host=None):
-        return self.route(uri, methods=["POST"], host=host)
+    def post(self, uri, host=None, strict_slashes=False, stream=False,
+             version=None):
+        return self.route(uri, methods=["POST"], host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def put(self, uri, host=None):
-        return self.route(uri, methods=["PUT"], host=host)
+    def put(self, uri, host=None, strict_slashes=False, stream=False,
+            version=None):
+        return self.route(uri, methods=["PUT"], host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def head(self, uri, host=None):
-        return self.route(uri, methods=["HEAD"], host=host)
+    def head(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=["HEAD"], host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def options(self, uri, host=None):
-        return self.route(uri, methods=["OPTIONS"], host=host)
+    def options(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=["OPTIONS"], host=host,
+                          strict_slashes=strict_slashes, version=version)
 
-    def patch(self, uri, host=None):
-        return self.route(uri, methods=["PATCH"], host=host)
+    def patch(self, uri, host=None, strict_slashes=False, stream=False,
+              version=None):
+        return self.route(uri, methods=["PATCH"], host=host,
+                          strict_slashes=strict_slashes, stream=stream,
+                          version=version)
 
-    def delete(self, uri, host=None):
-        return self.route(uri, methods=["DELETE"], host=host)
+    def delete(self, uri, host=None, strict_slashes=False, version=None):
+        return self.route(uri, methods=["DELETE"], host=host,
+                          strict_slashes=strict_slashes, version=version)

sanic/config.py

@@ -1,9 +1,106 @@
 import os
+import sys
+import syslog
+import platform
 import types
 
+from sanic.log import DefaultFilter
+
+SANIC_PREFIX = 'SANIC_'
+
+_address_dict = {
+    'Windows': ('localhost', 514),
+    'Darwin': '/var/run/syslog',
+    'Linux': '/dev/log',
+    'FreeBSD': '/var/run/log'
+}
+
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    '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'
+        },
+    },
+    '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 = """
                  ▄▄▄▄▄
@@ -26,8 +123,15 @@ class Config(dict):
 ▌     ▐                ▀▀▄▄▄▀
  ▀▀▄▄▀
 """
-        self.REQUEST_MAX_SIZE = 100000000  # 100 megababies
+        self.REQUEST_MAX_SIZE = 100000000  # 100 megabytes
         self.REQUEST_TIMEOUT = 60  # 60 seconds
+        self.KEEP_ALIVE = keep_alive
+        self.WEBSOCKET_MAX_SIZE = 2 ** 20  # 1 megabytes
+        self.WEBSOCKET_MAX_QUEUE = 32
+        self.GRACEFUL_SHUTDOWN_TIMEOUT = 15.0  # 15 sec
+
+        if load_env:
+            self.load_environment_vars()
 
     def __getattr__(self, attr):
         try:
@@ -90,3 +194,19 @@ 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)
+                try:
+                    self[config_key] = int(v)
+                except ValueError:
+                    try:
+                        self[config_key] = float(v)
+                    except ValueError:
+                        self[config_key] = v

sanic/cookies.py

@@ -19,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.
@@ -116,9 +116,8 @@ class Cookie(dict):
                     ))
                 except AttributeError:
                     output.append('%s=%s' % (self._keys[key], value))
-            elif key in self._flags:
-                if self[key]:
-                    output.append(self._keys[key])
+            elif key in self._flags and self[key]:
+                output.append(self._keys[key])
             else:
                 output.append('%s=%s' % (self._keys[key], value))
 

sanic/exceptions.py

@@ -1,3 +1,5 @@
+from sanic.response import ALL_STATUS_CODES, COMMON_STATUS_CODES
+
 TRACEBACK_STYLE = '''
     <style>
         body {
@@ -47,6 +49,10 @@ TRACEBACK_STYLE = '''
             padding: 5px 10px;
         }
 
+        .tb-border {
+            padding-top: 20px;
+        }
+
         .frame-descriptor {
             background-color: #e2eafb;
         }
@@ -63,20 +69,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">
@@ -96,6 +117,20 @@ INTERNAL_SERVER_ERROR_HTML = '''
 '''
 
 
+_sanic_exceptions = {}
+
+
+def add_status_code(code):
+    """
+    Decorator used for adding exceptions to _sanic_exceptions.
+    """
+    def class_decorator(cls):
+        cls.status_code = code
+        _sanic_exceptions[code] = cls
+        return cls
+    return class_decorator
+
+
 class SanicException(Exception):
 
     def __init__(self, message, status_code=None):
@@ -105,24 +140,27 @@ class SanicException(Exception):
             self.status_code = status_code
 
 
+@add_status_code(404)
 class NotFound(SanicException):
-    status_code = 404
+    pass
 
 
+@add_status_code(400)
 class InvalidUsage(SanicException):
-    status_code = 400
+    pass
 
 
+@add_status_code(500)
 class ServerError(SanicException):
-    status_code = 500
+    pass
 
 
-class URLBuildError(SanicException):
-    status_code = 500
+class URLBuildError(ServerError):
+    pass
 
 
 class FileNotFound(NotFound):
-    status_code = 404
+    pass
 
     def __init__(self, message, path, relative_url):
         super().__init__(message)
@@ -130,20 +168,23 @@ class FileNotFound(NotFound):
         self.relative_url = relative_url
 
 
+@add_status_code(408)
 class RequestTimeout(SanicException):
-    status_code = 408
+    pass
 
 
+@add_status_code(413)
 class PayloadTooLarge(SanicException):
-    status_code = 413
+    pass
 
 
-class HeaderNotFound(SanicException):
-    status_code = 400
+class HeaderNotFound(InvalidUsage):
+    pass
 
 
+@add_status_code(416)
 class ContentRangeError(SanicException):
-    status_code = 416
+    pass
 
     def __init__(self, message, content_range):
         super().__init__(message)
@@ -153,5 +194,69 @@ class ContentRangeError(SanicException):
         }
 
 
+@add_status_code(403)
+class Forbidden(SanicException):
+    pass
+
+
 class InvalidRangeType(ContentRangeError):
     pass
+
+
+@add_status_code(401)
+class Unauthorized(SanicException):
+    """
+    Unauthorized exception (401 HTTP status code).
+
+    :param message: Message describing the exception.
+    :param scheme: Name of the authentication scheme to be used.
+
+    When present, kwargs is used to complete the WWW-Authentication header.
+
+    Examples::
+
+        # With a Basic auth-scheme, realm MUST be present:
+        raise Unauthorized("Auth required.", "Basic", realm="Restricted Area")
+
+        # With a Digest auth-scheme, things are a bit more complicated:
+        raise Unauthorized("Auth required.",
+                           "Digest",
+                           realm="Restricted Area",
+                           qop="auth, auth-int",
+                           algorithm="MD5",
+                           nonce="abcdef",
+                           opaque="zyxwvu")
+
+        # With a Bearer auth-scheme, realm is optional so you can write:
+        raise Unauthorized("Auth required.", "Bearer")
+
+        # or, if you want to specify the realm:
+        raise Unauthorized("Auth required.", "Bearer", realm="Restricted Area")
+    """
+    def __init__(self, message, scheme, **kwargs):
+        super().__init__(message)
+
+        values = ["{!s}={!r}".format(k, v) for k, v in kwargs.items()]
+        challenge = ', '.join(values)
+
+        self.headers = {
+            "WWW-Authenticate": "{} {}".format(scheme, challenge).rstrip()
+        }
+
+
+def abort(status_code, message=None):
+    """
+    Raise an exception based on SanicException. Returns the HTTP response
+    message appropriate for the given status code, unless provided.
+
+    :param status_code: The HTTP status code to return.
+    :param message: The HTTP response body. Defaults to the messages
+                    in response.py for the given status code.
+    """
+    if message is None:
+        message = COMMON_STATUS_CODES.get(status_code,
+                                          ALL_STATUS_CODES.get(status_code))
+        # These are stored as bytes in the STATUS_CODES dict
+        message = message.decode('utf8')
+    sanic_exception = _sanic_exceptions.get(status_code, SanicException)
+    raise sanic_exception(message=message, status_code=status_code)

sanic/handlers.py

@@ -9,35 +9,63 @@ from sanic.exceptions import (
     SanicException,
     TRACEBACK_LINE_HTML,
     TRACEBACK_STYLE,
-    TRACEBACK_WRAPPER_HTML)
+    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.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)
+    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=exc_type.__name__,
-            exc_value=exc_value,
-            frame_html=''.join(frame_html),
-            uri=request.url)
+            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[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
@@ -47,9 +75,13 @@ class ErrorHandler:
         :param exception: Exception to handle
         :return: Response object
         """
-        handler = self.handlers.get(type(exception), self.default)
+        handler = self.lookup(exception)
+        response = None
         try:
-            response = handler(request=request, exception=exception)
+            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:

sanic/log.py

@@ -1,3 +1,18 @@
 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
+
+
 log = logging.getLogger('sanic')
+netlog = logging.getLogger('network')

sanic/request.py

@@ -1,13 +1,20 @@
+import sys
+import json
 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 urllib.parse import parse_qs, urlunparse
 
 try:
     from ujson import loads as json_loads
 except ImportError:
-    from json import loads as json_loads
+    if sys.version_info[:2] == (3, 5):
+        def json_loads(data):
+            # on Python 3.5 json.loads only supports str not bytes
+            return json.loads(data.decode())
+    else:
+        json_loads = json.loads
 
 from sanic.exceptions import InvalidUsage
 from sanic.log import log
@@ -36,24 +43,20 @@ class RequestParameters(dict):
 class Request(dict):
     """Properties of an HTTP request such as URL, headers, etc."""
     __slots__ = (
-        'app', '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', 'stream', '_remote_addr'
     )
 
     def __init__(self, url_bytes, headers, version, method, transport):
         # TODO: Content-Encoding detection
-        url_parsed = parse_url(url_bytes)
+        self._parsed_url = parse_url(url_bytes)
         self.app = None
-        self.url = url_parsed.path.decode('utf-8')
+
         self.headers = headers
         self.version = version
         self.method = method
         self.transport = transport
-        self.query_string = None
-        if url_parsed.query:
-            self.query_string = url_parsed.query.decode('utf-8')
 
         # Init but do not inhale
         self.body = []
@@ -61,7 +64,9 @@ class Request(dict):
         self.parsed_form = None
         self.parsed_files = None
         self.parsed_args = None
+        self.uri_template = None
         self._cookies = None
+        self.stream = None
 
     @property
     def json(self):
@@ -69,6 +74,8 @@ 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
@@ -79,9 +86,14 @@ class Request(dict):
 
         :return: token related to request
         """
+        prefixes = ('Bearer', 'Token')
         auth_header = self.headers.get('Authorization')
+
         if auth_header is not None:
-            return auth_header.split()[1]
+            for prefix in prefixes:
+                if prefix in auth_header:
+                    return auth_header.partition(prefix)[-1].strip()
+
         return auth_header
 
     @property
@@ -123,10 +135,14 @@ class Request(dict):
                 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:
-            cookie = self.headers.get('Cookie') or self.headers.get('cookie')
+            cookie = self.headers.get('Cookie')
             if cookie is not None:
                 cookies = SimpleCookie()
                 cookies.load(cookie)
@@ -139,9 +155,78 @@ class Request(dict):
     @property
     def ip(self):
         if not hasattr(self, '_ip'):
-            self._ip = self.transport.get_extra_info('peername')
+            self._ip = (self.transport.get_extra_info('peername') or
+                        (None, None))
         return self._ip
 
+    @property
+    def remote_addr(self):
+        """Attempt to return the original client ip based on X-Forwarded-For.
+
+        :return: original client ip.
+        """
+        if not hasattr(self, '_remote_addr'):
+            forwarded_for = self.headers.get('X-Forwarded-For', '').split(',')
+            remote_addrs = [
+                addr for addr in [
+                    addr.strip() for addr in forwarded_for
+                ] if addr
+            ]
+            if len(remote_addrs) > 0:
+                self._remote_addr = remote_addrs[0]
+            else:
+                self._remote_addr = ''
+        return self._remote_addr
+
+    @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 content_type(self):
+        return self.headers.get('Content-Type', DEFAULT_HTTP_CONTENT_TYPE)
+
+    @property
+    def match_info(self):
+        """return matched info after resolving route"""
+        return self.app.router.get(self)[2]
+
+    @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'])
 
@@ -172,15 +257,15 @@ def parse_multipart_form(body, boundary):
                 break
 
             colon_index = form_line.index(':')
-            form_header_field = form_line[0:colon_index]
+            form_header_field = form_line[0:colon_index].lower()
             form_header_value, form_parameters = parse_header(
                 form_line[colon_index + 2:])
 
-            if form_header_field == 'Content-Disposition':
+            if form_header_field == 'content-disposition':
                 if 'filename' in form_parameters:
                     file_name = form_parameters['filename']
                 field_name = form_parameters.get('name')
-            elif form_header_field == 'Content-Type':
+            elif form_header_field == 'content-type':
                 file_type = form_header_value
 
         post_data = form_part[line_index:-4]

sanic/response.py

@@ -1,6 +1,10 @@
 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 aiofiles import open as open_async
 
@@ -73,37 +77,16 @@ 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:
-            try:
-                # Try to encode it regularly
-                self.body = body.encode()
-            except AttributeError:
-                # Convert it to a str if you can't
-                self.body = str(body).encode()
-        else:
-            self.body = body_bytes
-
-        self.status = status
-        self.headers = headers or {}
-        self._cookies = None
-
-    def output(self, version="1.1", keep_alive=False, keep_alive_timeout=None):
-        # This is all returned in a kind-of funky way
-        # We tried to make this as fast as possible in pure python
-        timeout_header = b''
-        if keep_alive and keep_alive_timeout 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)
+    def _parse_headers(self):
         headers = b''
         for name, value in self.headers.items():
             try:
@@ -115,25 +98,7 @@ class HTTPResponse:
                     b'%b: %b\r\n' % (
                         str(name).encode(), str(value).encode('utf-8')))
 
-        # Try to pull from the common codes first
-        # Speeds up response rate 6% over pulling from all
-        status = COMMON_STATUS_CODES.get(self.status)
-        if not status:
-            status = ALL_STATUS_CODES.get(self.status)
-
-        return (b'HTTP/%b %d %b\r\n'
-                b'Connection: %b\r\n'
-                b'%b'
-                b'%b\r\n'
-                b'%b') % (
-            version.encode(),
-            self.status,
-            status,
-            b'keep-alive' if keep_alive else b'close',
-            timeout_header,
-            headers,
-            self.body
-        )
+        return headers
 
     @property
     def cookies(self):
@@ -142,41 +107,170 @@ class HTTPResponse:
         return self._cookies
 
 
-def json(body, status=200, headers=None, **kwargs):
+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 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 is not None:
+            timeout_header = b'Keep-Alive: %d\r\n' % keep_alive_timeout
+
+        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
+        status = COMMON_STATUS_CODES.get(self.status)
+        if not status:
+            status = ALL_STATUS_CODES.get(self.status)
+
+        return (b'HTTP/%b %d %b\r\n'
+                b'%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'%b\r\n'
+                b'%b') % (
+                   version.encode(),
+                   self.status,
+                   status,
+                   b'keep-alive' if keep_alive else b'close',
+                   timeout_header,
+                   headers,
+                   self.body
+               )
+
+    @property
+    def cookies(self):
+        if self._cookies is None:
+            self._cookies = CookieJar(self.headers)
+        return self._cookies
+
+
+def json(body, status=200, headers=None,
+         content_type="application/json", **kwargs):
     """
     Returns response object with body in json format.
+
     :param body: Response data to be serialized.
     :param status: Response code.
     :param headers: Custom Headers.
     :param kwargs: Remaining arguments that are passed to the json encoder.
     """
     return HTTPResponse(json_dumps(body, **kwargs), headers=headers,
-                        status=status, content_type="application/json")
+                        status=status, content_type=content_type)
 
 
 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
+    :param content_type: the content type (string) of the response
     """
-    return HTTPResponse(body, status=status, headers=headers,
-                        content_type=content_type)
+    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
+    :param content_type: the content type (string) of the response.
     """
     return HTTPResponse(body_bytes=body, status=status, headers=headers,
                         content_type=content_type)
@@ -185,6 +279,7 @@ def raw(body, status=200, headers=None,
 def html(body, status=200, headers=None):
     """
     Returns response object with body in html format.
+
     :param body: Response data to be encoded.
     :param status: Response code.
     :param headers: Custom Headers.
@@ -220,6 +315,82 @@ async def file(location, mime_type=None, headers=None, _range=None):
                         body_bytes=out_stream)
 
 
+async def file_stream(location, chunk_size=4096, mime_type=None, headers=None,
+                      _range=None):
+    """Return a streaming response object with file data.
+
+    :param location: Location of file on system.
+    :param chunk_size: The size of each chunk in the stream (in bytes)
+    :param mime_type: Specific mime_type.
+    :param headers: Custom Headers.
+    :param _range:
+    """
+    filename = path.split(location)[-1]
+
+    _file = await open_async(location, mode='rb')
+
+    async def _streaming_fn(response):
+        nonlocal _file, chunk_size
+        try:
+            if _range:
+                chunk_size = min((_range.size, chunk_size))
+                await _file.seek(_range.start)
+                to_send = _range.size
+                while to_send > 0:
+                    content = await _file.read(chunk_size)
+                    if len(content) < 1:
+                        break
+                    to_send -= len(content)
+                    response.write(content)
+            else:
+                while True:
+                    content = await _file.read(chunk_size)
+                    if len(content) < 1:
+                        break
+                    response.write(content)
+        finally:
+            await _file.close()
+        return  # Returning from this fn closes the stream
+
+    mime_type = mime_type or guess_type(filename)[0] or 'text/plain'
+    if _range:
+        headers['Content-Range'] = 'bytes %s-%s/%s' % (
+            _range.start, _range.end, _range.total)
+    return StreamingHTTPResponse(streaming_fn=_streaming_fn,
+                                 status=200,
+                                 headers=headers,
+                                 content_type=mime_type)
+
+
+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"):
     """Abort execution and cause a 302 redirect (by default).

sanic/router.py

@@ -8,7 +8,7 @@ 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 = {
@@ -16,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
@@ -71,13 +72,15 @@ class Router:
         self.routes_always_check = []
         self.hosts = set()
 
-    def parse_parameter_string(self, parameter_string):
+    @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]')
+        For example::
+
+            parse_parameter_string('<param_one:[A-z]>')` ->
+                ('param_one', str, '[A-z]')
 
         :param parameter_string: String to parse
         :return: tuple containing
@@ -95,9 +98,32 @@ class Router:
 
         return name, _type, pattern
 
-    def add(self, uri, methods, handler, host=None):
+    def add(self, uri, methods, handler, host=None, strict_slashes=False,
+            version=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.
+        :param strict_slashes: strict to trailing slash
+        :param version: current version of the route or blueprint. See
+            docs for further details.
+        :return: Nothing
+        """
+        if version is not None:
+            if uri.startswith('/'):
+                uri = "/".join(["/v{}".format(str(version)), uri[1:]])
+            else:
+                uri = "/".join(["/v{}".format(str(version)), uri])
         # 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)
@@ -137,9 +163,6 @@ class Router:
                 for host_ in host:
                     self.add(uri, methods, handler, host_)
                 return
-        else:
-            # default host
-            self.hosts.add('*')
 
         # Dict for faster lookups of if method allowed
         if methods:
@@ -157,10 +180,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)
@@ -219,7 +242,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']:
@@ -281,14 +304,14 @@ class Router:
         """
         # No virtual hosts specified; default behavior
         if not self.hosts:
-            return self._get(request.url, request.method, '')
+            return self._get(request.path, request.method, '')
         # virtual hosts specified; try to match route to the host header
         try:
-            return self._get(request.url, request.method,
+            return self._get(request.path, request.method,
                              request.headers.get("Host", ''))
         # try default hosts
         except NotFound:
-            return self._get(request.url, request.method, '')
+            return self._get(request.path, request.method, '')
 
     @lru_cache(maxsize=ROUTER_CACHE_SIZE)
     def _get(self, url, method, host):
@@ -338,4 +361,18 @@ 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
+
+    def is_stream_handler(self, request):
+        """ Handler for request is stream or not.
+        :param request: Request object
+        :return: bool
+        """
+        try:
+            handler = self.get(request)[0]
+        except (NotFound, InvalidUsage):
+            return False
+        if (hasattr(handler, 'view_class') and
+                hasattr(handler.view_class, request.method.lower())):
+            handler = getattr(handler.view_class, request.method.lower())
+        return hasattr(handler, 'is_stream')

sanic/server.py

@@ -1,14 +1,19 @@
 import asyncio
 import os
 import traceback
-import warnings
 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
 
 from httptools import HttpRequestParser
@@ -19,7 +24,8 @@ try:
 except ImportError:
     async_loop = asyncio
 
-from sanic.log import log
+from sanic.log import log, netlog
+from sanic.response import HTTPResponse
 from sanic.request import Request
 from sanic.exceptions import (
     RequestTimeout, PayloadTooLarge, InvalidUsage, ServerError)
@@ -58,28 +64,53 @@ class HttpProtocol(asyncio.Protocol):
         'parser', 'request', 'url', 'headers',
         # request config
         'request_handler', 'request_timeout', 'request_max_size',
+        'request_class', 'is_request_stream', 'router',
+        # enable or disable access log / error log purpose
+        'has_log',
         # connection management
-        '_total_request_size', '_timeout_handler', '_last_communication_time')
+        '_total_request_size', '_timeout_handler', '_last_communication_time',
+        '_is_stream_handler')
 
     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, is_request_stream=False, router=None,
+                 state=None, debug=False, **kwargs):
         self.loop = loop
         self.transport = None
         self.request = None
         self.parser = None
         self.url = None
         self.headers = None
+        self.router = router
         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.is_request_stream = is_request_stream
+        self._is_stream_handler = False
         self._total_request_size = 0
         self._timeout_handler = None
         self._last_request_time = None
         self._request_handler_task = None
+        self._request_stream_task = None
+        self._keep_alive = keep_alive
+        self._header_fragment = b''
+        self.state = state if state else {}
+        if 'requests_count' not in self.state:
+            self.state['requests_count'] = 0
+        self._debug = debug
+
+    @property
+    def keep_alive(self):
+        return (
+            self._keep_alive and
+            not self.signal.stopped and
+            self.parser.should_keep_alive())
 
     # -------------------------------------------- #
     # Connection
@@ -104,10 +135,14 @@ class HttpProtocol(asyncio.Protocol):
             self._timeout_handler = (
                 self.loop.call_later(time_left, self.connection_timeout))
         else:
+            if self._request_stream_task:
+                self._request_stream_task.cancel()
             if self._request_handler_task:
                 self._request_handler_task.cancel()
-            exception = RequestTimeout('Request Timeout')
-            self.write_error(exception)
+            try:
+                raise RequestTimeout('Request Timeout')
+            except RequestTimeout as exception:
+                self.write_error(exception)
 
     # -------------------------------------------- #
     # Parsing
@@ -127,52 +162,141 @@ class HttpProtocol(asyncio.Protocol):
             self.headers = []
             self.parser = HttpRequestParser(self)
 
+        # requests count
+        self.state['requests_count'] = self.state['requests_count'] + 1
+
         # Parse request chunk or close connection
         try:
             self.parser.feed_data(data)
         except HttpParserError:
-            exception = InvalidUsage('Bad Request')
+            message = 'Bad Request'
+            if self._debug:
+                message += '\n' + traceback.format_exc()
+            exception = InvalidUsage(message)
             self.write_error(exception)
 
     def on_url(self, url):
-        self.url = url
+        if not self.url:
+            self.url = url
+        else:
+            self.url += url
 
     def on_header(self, name, value):
-        if name == b'Content-Length' and int(value) > self.request_max_size:
-            exception = PayloadTooLarge('Payload Too Large')
-            self.write_error(exception)
+        self._header_fragment += name
 
-        self.headers.append((name.decode().casefold(), value.decode()))
+        if value is not None:
+            if self._header_fragment == b'Content-Length' \
+                    and int(value) > self.request_max_size:
+                exception = PayloadTooLarge('Payload Too Large')
+                self.write_error(exception)
+
+            self.headers.append(
+                    (self._header_fragment.decode().casefold(),
+                     value.decode()))
+
+            self._header_fragment = b''
 
     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(),
             method=self.parser.get_method().decode(),
             transport=self.transport
         )
+        if self.is_request_stream:
+            self._is_stream_handler = self.router.is_stream_handler(
+                self.request)
+            if self._is_stream_handler:
+                self.request.stream = asyncio.Queue()
+                self.execute_request_handler()
 
     def on_body(self, body):
+        if self.is_request_stream and self._is_stream_handler:
+            self._request_stream_task = self.loop.create_task(
+                self.request.stream.put(body))
+            return
         self.request.body.append(body)
 
     def on_message_complete(self):
-        if self.request.body:
-            self.request.body = b''.join(self.request.body)
+        if self.is_request_stream and self._is_stream_handler:
+            self._request_stream_task = self.loop.create_task(
+                self.request.stream.put(None))
+            return
+        self.request.body = b''.join(self.request.body)
+        self.execute_request_handler()
+
+    def execute_request_handler(self):
         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):
-        keep_alive = (
-            self.parser.should_keep_alive() and not self.signal.stopped)
+        """
+        Writes response content synchronously to the transport.
+        """
         try:
+            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': '{0}:{1}'.format(self.request.ip[0],
+                                             self.request.ip[1]),
+                    'request': '{0} {1}'.format(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:
+                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': '{0}:{1}'.format(self.request.ip[0],
+                                             self.request.ip[1]),
+                    'request': '{0} {1}'.format(self.request.method,
+                                                self.request.url)
+                })
         except AttributeError:
             log.error(
                 ('Invalid response object for url {}, '
@@ -191,11 +315,11 @@ class HttpProtocol(asyncio.Protocol):
             if not keep_alive:
                 self.transport.close()
             else:
-                # Record that we received data
                 self._last_request_time = current_time
                 self.cleanup()
 
     def write_error(self, exception):
+        response = None
         try:
             response = self.error_handler.response(self.request, exception)
             version = self.request.version if self.request else '1.1'
@@ -209,10 +333,28 @@ class HttpProtocol(asyncio.Protocol):
                 "Writing error failed, connection closed {}".format(repr(e)),
                 from_error=True)
         finally:
+            if self.has_log:
+                extra = dict()
+                if isinstance(response, HTTPResponse):
+                    extra['status'] = response.status
+                    extra['byte'] = len(response.body)
+                else:
+                    extra['status'] = 0
+                    extra['byte'] = -1
+                if self.request:
+                    extra['host'] = '%s:%d' % self.request.ip,
+                    extra['request'] = '%s %s' % (self.request.method,
+                                                  self.url)
+                else:
+                    extra['host'] = 'UNKNOWN'
+                    extra['request'] = 'nil'
+                if self.parser and not (self.keep_alive
+                                        and extra['status'] == 408):
+                    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(
@@ -230,7 +372,9 @@ class HttpProtocol(asyncio.Protocol):
         self.url = None
         self.headers = None
         self._request_handler_task = None
+        self._request_stream_task = None
         self._total_request_size = 0
+        self._is_stream_handler = False
 
     def close_if_idle(self):
         """Close the connection if a request is not being sent or received
@@ -242,6 +386,14 @@ class HttpProtocol(asyncio.Protocol):
             return True
         return False
 
+    def close(self):
+        """
+        Force close the connection.
+        """
+        if self.transport is not None:
+            self.transport.close()
+            self.transport = None
+
 
 def update_current_time(loop):
     """Cache the current time, since it is needed at the end of every
@@ -271,7 +423,11 @@ 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):
+          register_sys_signals=True, run_async=False, connections=None,
+          signal=Signal(), request_class=None, has_log=True, keep_alive=True,
+          is_request_stream=False, router=None, websocket_max_size=None,
+          websocket_max_queue=None, state=None,
+          graceful_shutdown_timeout=15.0):
     """Start asynchronous HTTP Server on an individual process.
 
     :param host: Address to host on
@@ -287,7 +443,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
                         `app` instance and `loop`
     :param after_stop: function to be executed when a stop signal is
                        received after it is respected. Takes arguments
-                        `app` instance and `loop`
+                       `app` instance and `loop`
     :param debug: enables debug output (slows server)
     :param request_timeout: time in seconds
     :param ssl: SSLContext
@@ -296,6 +452,10 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     :param reuse_port: `True` for multiple workers
     :param loop: asyncio compatible event loop
     :param protocol: subclass of asyncio protocol class
+    :param request_class: Request class to use
+    :param has_log: disable/enable access log and error log
+    :param is_request_stream: disable/enable Request.stream
+    :param router: Router object
     :return: Nothing
     """
     if not run_async:
@@ -305,10 +465,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     if debug:
         loop.set_debug(debug)
 
-    trigger_events(before_start, loop)
-
-    connections = set()
-    signal = Signal()
+    connections = connections if connections is not None else set()
     server = partial(
         protocol,
         loop=loop,
@@ -318,6 +475,15 @@ 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,
+        is_request_stream=is_request_stream,
+        router=router,
+        websocket_max_size=websocket_max_size,
+        websocket_max_queue=websocket_max_queue,
+        state=state,
+        debug=debug,
     )
 
     server_coroutine = loop.create_server(
@@ -329,6 +495,7 @@ def serve(host, port, request_handler, error_handler, before_start=None,
         sock=sock,
         backlog=backlog
     )
+
     # Instead of pulling time at the end of every request,
     # pull it once per minute
     loop.call_soon(partial(update_current_time, loop))
@@ -336,6 +503,8 @@ def serve(host, port, request_handler, error_handler, before_start=None,
     if run_async:
         return server_coroutine
 
+    trigger_events(before_start, loop)
+
     try:
         http_server = loop.run_until_complete(server_coroutine)
     except:
@@ -371,15 +540,33 @@ def serve(host, port, request_handler, error_handler, before_start=None,
         for connection in connections:
             connection.close_if_idle()
 
-        while connections:
+        # Gracefully shutdown timeout.
+        # We should provide graceful_shutdown_timeout,
+        # instead of letting connection hangs forever.
+        # Let's roughly calcucate time.
+        start_shutdown = 0
+        while connections and (start_shutdown < graceful_shutdown_timeout):
             loop.run_until_complete(asyncio.sleep(0.1))
+            start_shutdown = start_shutdown + 0.1
+
+        # Force close non-idle connection after waiting for
+        # graceful_shutdown_timeout
+        coros = []
+        for conn in connections:
+            if hasattr(conn, "websocket") and conn.websocket:
+                coros.append(conn.websocket.close_connection(force=True))
+            else:
+                conn.close()
+
+        _shutdown = asyncio.gather(*coros, loop=loop)
+        loop.run_until_complete(_shutdown)
 
         trigger_events(after_stop, loop)
 
         loop.close()
 
 
-def serve_multiple(server_settings, workers, stop_event=None):
+def serve_multiple(server_settings, workers):
     """Start multiple server processes simultaneously.  Stop on interrupt
     and terminate signals, and drain connections when complete.
 
@@ -388,27 +575,26 @@ def serve_multiple(server_settings, workers, stop_event=None):
     :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):
@@ -423,6 +609,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

@@ -13,11 +13,12 @@ from sanic.exceptions import (
     InvalidUsage,
 )
 from sanic.handlers import ContentRangeHandler
-from sanic.response import file, HTTPResponse
+from sanic.response import file, file_stream, HTTPResponse
 
 
 def register(app, uri, file_or_directory, pattern,
-             use_modified_since, use_content_range):
+             use_modified_since, use_content_range,
+             stream_large_files):
     # 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
@@ -34,6 +35,10 @@ def register(app, uri, file_or_directory, pattern,
                                server's
     :param use_content_range: If true, process header for range requests
                               and sends the file part that is requested
+    :param stream_large_files: If true, use the file_stream() handler rather
+                              than the file() handler to send the file
+                              If this is an integer, this represents the
+                              threshold size to switch to file_stream()
     """
     # If we're not trying to match a file directly,
     # serve from the folder
@@ -48,14 +53,18 @@ def register(app, uri, file_or_directory, pattern,
         # 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
@@ -89,6 +98,17 @@ def register(app, uri, file_or_directory, pattern,
                     headers=headers,
                     content_type=guess_type(file_path)[0] or 'text/plain')
             else:
+                if stream_large_files:
+                    if isinstance(stream_large_files, int):
+                        threshold = stream_large_files
+                    else:
+                        threshold = 1024*1000
+
+                    if not stats:
+                        stats = await stat(file_path)
+                    if stats.st_size >= threshold:
+                        return await file_stream(file_path, headers=headers,
+                                                 _range=_range)
                 return await file(file_path, headers=headers, _range=_range)
         except ContentRangeError:
             raise

sanic/testing.py

@@ -1,10 +1,13 @@
+import traceback
+from json import JSONDecodeError
+
 from sanic.log import log
 
 HOST = '127.0.0.1'
 PORT = 42101
 
 
-class TestClient:
+class SanicTestClient:
     def __init__(self, app):
         self.app = app
 
@@ -17,10 +20,23 @@ class TestClient:
                 host=HOST, port=PORT, uri=uri)
 
         log.info(url)
-        async with aiohttp.ClientSession(cookies=cookies) as session:
+        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:
-                response.text = await response.text()
+                try:
+                    response.text = await response.text()
+                except UnicodeDecodeError as e:
+                    response.text = None
+
+                try:
+                    response.json = await response.json()
+                except (JSONDecodeError,
+                        UnicodeDecodeError,
+                        aiohttp.ClientResponseError):
+                    response.json = None
+
                 response.body = await response.read()
                 return response
 
@@ -45,6 +61,8 @@ class TestClient:
                     **request_kwargs)
                 results[-1] = response
             except Exception as e:
+                log.error(
+                    'Exception:\n{}'.format(traceback.format_exc()))
                 exceptions.append(e)
             self.app.stop()
 

sanic/utils.py

@@ -1,17 +0,0 @@
-import warnings
-
-from sanic.testing import TestClient
-
-
-def sanic_endpoint_test(app, method='get', uri='/', gather_request=True,
-                        debug=False, server_kwargs={},
-                        *request_args, **request_kwargs):
-    warnings.warn(
-        "Use of sanic_endpoint_test will be deprecated in"
-        "the next major version after 0.4.0.  Please use the `test_client` "
-        "available on the app object.", DeprecationWarning)
-
-    test_client = TestClient(app)
-    return test_client._sanic_endpoint_test(
-        method, uri, gather_request, debug, server_kwargs,
-        *request_args, **request_kwargs)

sanic/views.py

@@ -64,6 +64,11 @@ class HTTPMethodView:
         return view
 
 
+def stream(func):
+    func.is_stream = True
+    return func
+
+
 class CompositionView:
     """Simple method-function mapped view for the sanic.
     You can add handler functions to methods (get, post, put, patch, delete)
@@ -83,7 +88,9 @@ class CompositionView:
     def __init__(self):
         self.handlers = {}
 
-    def add(self, methods, handler):
+    def add(self, methods, handler, stream=False):
+        if stream:
+            handler.is_stream = stream
         for method in methods:
             if method not in HTTP_METHODS:
                 raise InvalidUsage(

sanic/websocket.py

@@ -0,0 +1,73 @@
+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, websocket_max_size=None,
+                 websocket_max_queue=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.websocket = None
+        self.websocket_max_size = websocket_max_size
+        self.websocket_max_queue = websocket_max_queue
+
+    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(
+            max_size=self.websocket_max_size,
+            max_queue=self.websocket_max_queue
+        )
+        self.websocket.connection_made(request.transport)
+        return self.websocket

sanic/worker.py

@@ -0,0 +1,205 @@
+import os
+import sys
+import signal
+import asyncio
+import logging
+import traceback
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+try:
+    import uvloop
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+except ImportError:
+    pass
+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()
+
+        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(
+            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())
+        except:
+            traceback.print_exc()
+        finally:
+            try:
+                trigger_events(self._server_settings.get('after_stop', []),
+                               self.loop)
+            except:
+                traceback.print_exc()
+            finally:
+                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()
+
+            # gracefully shutdown timeout
+            start_shutdown = 0
+            graceful_shutdown_timeout = self.cfg.graceful_timeout
+            while self.connections and \
+                    (start_shutdown < graceful_shutdown_timeout):
+                await asyncio.sleep(0.1)
+                start_shutdown = start_shutdown + 0.1
+
+            # Force close non-idle connection after waiting for
+            # graceful_shutdown_timeout
+            coros = []
+            for conn in self.connections:
+                if hasattr(conn, "websocket") and conn.websocket:
+                    coros.append(conn.websocket.close_connection(force=True))
+                else:
+                    conn.close()
+            _shutdown = asyncio.gather(*coros, loop=self.loop)
+            await _shutdown
+
+    async def _run(self):
+        for sock in self.sockets:
+            state = dict(requests_count=0)
+            self._server_settings["host"] = None
+            self._server_settings["port"] = None
+            server = await serve(
+                sock=sock,
+                connections=self.connections,
+                state=state,
+                **self._server_settings
+            )
+            self.servers[server] = state
+
+    async def _check_alive(self):
+        # If our parent changed then we shut down.
+        pid = os.getpid()
+        try:
+            while self.alive:
+                self.notify()
+
+                req_count = sum(
+                    self.servers[srv]["requests_count"] for srv in self.servers
+                )
+                if self.max_requests and req_count > self.max_requests:
+                    self.alive = False
+                    self.log.info(
+                            "Max requests exceeded, shutting down: %s", self
+                        )
+                elif 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.app.callable.is_running = False
+        self.cfg.worker_int(self)
+
+    def handle_abort(self, sig, frame):
+        self.alive = False
+        self.exit_code = 1
+        self.cfg.worker_abort(self)
+        sys.exit(1)

setup.py

@@ -4,43 +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.')
 
-install_requires = [
-    'httptools>=0.0.9',
-    'ujson>=1.35',
-    'aiofiles>=0.3.0',
-]
 
-if os.name != 'nt':
-    install_requires.append('uvloop>=0.5.3')
+with open_local(['README.rst']) as rm:
+    long_description = rm.read()
 
-setup(
-    name='sanic',
-    version=version,
-    url='http://github.com/channelcat/sanic/',
-    license='MIT',
-    author='Channel Cat',
-    author_email='channelcat@gmail.com',
-    description=(
+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'),
-    packages=['sanic'],
-    platforms='any',
-    install_requires=install_requires,
-    classifiers=[
+    '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/test_blueprints.py

@@ -1,15 +1,42 @@
+import asyncio
 import inspect
+import pytest
 
 from sanic import Sanic
 from sanic.blueprints import Blueprint
 from sanic.response import json, text
 from sanic.exceptions import NotFound, ServerError, InvalidUsage
+from sanic.constants import HTTP_METHODS
 
 
 # ------------------------------------------------------------ #
 #  GET
 # ------------------------------------------------------------ #
 
+@pytest.mark.parametrize('method', HTTP_METHODS)
+def test_versioned_routes_get(method):
+    app = Sanic('test_shorhand_routes_get')
+    bp = Blueprint('test_text')
+
+    method = method.lower()
+
+    func = getattr(bp, method)
+    if callable(func):
+        @func('/{}'.format(method), version=1)
+        def handler(request):
+            return text('OK')
+    else:
+        print(func)
+        raise
+
+    app.blueprint(bp)
+
+    client_method = getattr(app.test_client, method)
+
+    request, response = client_method('/v1/{}'.format(method))
+    assert response.status == 200
+
+
 def test_bp():
     app = Sanic('test_text')
     bp = Blueprint('test_text')
@@ -20,9 +47,38 @@ def test_bp():
 
     app.blueprint(bp)
     request, response = app.test_client.get('/')
+    assert app.is_request_stream is False
 
     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'
+    assert response.json == None
+
+    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')
@@ -236,37 +292,52 @@ def test_bp_static():
 def test_bp_shorthand():
     app = Sanic('test_shorhand_routes')
     blueprint = Blueprint('test_shorhand_routes')
+    ev = asyncio.Event()
 
     @blueprint.get('/get')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.put('/put')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.post('/post')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.head('/head')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.options('/options')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.patch('/patch')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
     @blueprint.delete('/delete')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
+    @blueprint.websocket('/ws')
+    async def handler(request, ws):
+        assert request.stream is None
+        ev.set()
+
     app.blueprint(blueprint)
 
+    assert app.is_request_stream is False
+
     request, response = app.test_client.get('/get')
     assert response.text == 'OK'
 
@@ -308,3 +379,11 @@ def test_bp_shorthand():
 
     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_create_task.py

@@ -1,16 +1,17 @@
-import sanic
-from sanic.utils import sanic_endpoint_test
+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.Sanic()
+    app = Sanic('test_create_task')
     app.add_task(coro)
 
     @app.route('/early')
@@ -22,9 +23,8 @@ def test_create_task():
         await asyncio.sleep(0.1)
         return text(e.is_set())
 
-
-    request, response = sanic_endpoint_test(app, uri='/early')
+    request, response = app.test_client.get('/early')
     assert response.body == b'False'
 
-    request, response = sanic_endpoint_test(app, uri='/late')
+    request, response = app.test_client.get('/late')
     assert response.body == b'True'

tests/test_exceptions.py

@@ -3,7 +3,8 @@ from bs4 import BeautifulSoup
 
 from sanic import Sanic
 from sanic.response import text
-from sanic.exceptions import InvalidUsage, ServerError, NotFound
+from sanic.exceptions import InvalidUsage, ServerError, NotFound, Unauthorized
+from sanic.exceptions import Forbidden, abort
 
 
 class SanicExceptionTestException(Exception):
@@ -26,10 +27,37 @@ def exception_app():
     def handler_404(request):
         raise NotFound("OK")
 
+    @app.route('/403')
+    def handler_403(request):
+        raise Forbidden("Forbidden")
+
+    @app.route('/401/basic')
+    def handler_401_basic(request):
+        raise Unauthorized("Unauthorized", "Basic", realm="Sanic")
+
+    @app.route('/401/digest')
+    def handler_401_digest(request):
+        raise Unauthorized("Unauthorized",
+                           "Digest",
+                           realm="Sanic",
+                           qop="auth, auth-int",
+                           algorithm="MD5",
+                           nonce="abcdef",
+                           opaque="zyxwvu")
+
+    @app.route('/401/bearer')
+    def handler_401_bearer(request):
+        raise Unauthorized("Unauthorized", "Bearer")
+
     @app.route('/invalid')
     def handler_invalid(request):
         raise InvalidUsage("OK")
 
+    @app.route('/abort')
+    def handler_invalid(request):
+        abort(500)
+        return text("OK")
+
     @app.route('/divide_by_zero')
     def handle_unhandled_exception(request):
         1 / 0
@@ -45,6 +73,24 @@ def exception_app():
     return app
 
 
+def test_catch_exception_list():
+    app = Sanic('exception_list')
+
+    @app.exception([SanicExceptionTestException, NotFound])
+    def exception_list(request, exception):
+        return text("ok")
+
+    @app.route('/')
+    def exception(request):
+        raise SanicExceptionTestException("You won't see me")
+
+    request, response = app.test_client.get('/random')
+    assert response.text == 'ok'
+
+    request, response = app.test_client.get('/')
+    assert response.text == 'ok'
+
+
 def test_no_exception(exception_app):
     """Test that a route works without an exception"""
     request, response = exception_app.test_client.get('/')
@@ -70,6 +116,35 @@ def test_not_found_exception(exception_app):
     assert response.status == 404
 
 
+def test_forbidden_exception(exception_app):
+    """Test the built-in Forbidden exception"""
+    request, response = exception_app.test_client.get('/403')
+    assert response.status == 403
+
+
+def test_unauthorized_exception(exception_app):
+    """Test the built-in Unauthorized exception"""
+    request, response = exception_app.test_client.get('/401/basic')
+    assert response.status == 401
+    assert response.headers.get('WWW-Authenticate') is not None
+    assert response.headers.get('WWW-Authenticate') == "Basic realm='Sanic'"
+
+    request, response = exception_app.test_client.get('/401/digest')
+    assert response.status == 401
+
+    auth_header = response.headers.get('WWW-Authenticate')
+    assert auth_header is not None
+    assert auth_header.startswith('Digest')
+    assert "qop='auth, auth-int'" in auth_header
+    assert "algorithm='MD5'" in auth_header
+    assert "nonce='abcdef'" in auth_header
+    assert "opaque='zyxwvu'" in auth_header
+
+    request, response = exception_app.test_client.get('/401/bearer')
+    assert response.status == 401
+    assert response.headers.get('WWW-Authenticate') == "Bearer"
+
+
 def test_handled_unhandled_exception(exception_app):
     """Test that an exception not built into sanic is handled"""
     request, response = exception_app.test_client.get('/divide_by_zero')
@@ -82,6 +157,7 @@ def test_handled_unhandled_exception(exception_app):
         "The server encountered an internal error and "
         "cannot complete your request.")
 
+
 def test_exception_in_exception_handler(exception_app):
     """Test that an exception thrown in an error handler is handled"""
     request, response = exception_app.test_client.get(
@@ -106,3 +182,9 @@ def test_exception_in_exception_handler_debug_off(exception_app):
         debug=True)
     assert response.status == 500
     assert response.body.startswith(b'Exception raised in exception ')
+
+
+def test_abort(exception_app):
+    """Test the abort function"""
+    request, response = exception_app.test_client.get('/abort')
+    assert response.status == 500

tests/test_exceptions_handler.py

@@ -1,6 +1,7 @@
 from sanic import Sanic
 from sanic.response import text
 from sanic.exceptions import InvalidUsage, ServerError, NotFound
+from sanic.handlers import ErrorHandler
 from bs4 import BeautifulSoup
 
 exception_handler_app = Sanic('test_exception_handler')
@@ -23,17 +24,26 @@ def handler_3(request):
 
 @exception_handler_app.route('/4')
 def handler_4(request):
-    foo = bar
+    foo = bar    # noqa -- F821 undefined name 'bar' is done to throw exception
     return text(foo)
 
 
 @exception_handler_app.route('/5')
 def handler_5(request):
     class CustomServerError(ServerError):
-        status_code=200
+        pass
     raise CustomServerError('Custom server error')
 
 
+@exception_handler_app.route('/6/<arg:int>')
+def handler_6(request, arg):
+    try:
+        foo = 1 / arg
+    except Exception as e:
+        raise e from ValueError("{}".format(arg))
+    return text(foo)
+
+
 @exception_handler_app.exception(NotFound, ServerError)
 def handler_exception(request, exception):
     return text("OK")
@@ -75,9 +85,70 @@ def test_html_traceback_output_in_debug_mode():
     summary_text = " ".join(soup.select('.summary')[0].text.split())
     assert (
         "NameError: name 'bar' "
-        "is not defined while handling uri /4") == summary_text
+        "is not defined while handling path /4") == summary_text
 
 
 def test_inherited_exception_handler():
     request, response = exception_handler_app.test_client.get('/5')
     assert response.status == 200
+
+
+def test_chained_exception_handler():
+    request, response = exception_handler_app.test_client.get(
+        '/6/0', debug=True)
+    assert response.status == 500
+
+    soup = BeautifulSoup(response.body, 'html.parser')
+    html = str(soup)
+
+    assert 'response = handler(request, *args, **kwargs)' in html
+    assert 'handler_6' in html
+    assert 'foo = 1 / arg' in html
+    assert 'ValueError' in html
+    assert 'The above exception was the direct cause' in html
+
+    summary_text = " ".join(soup.select('.summary')[0].text.split())
+    assert (
+        "ZeroDivisionError: division by zero "
+        "while handling path /6/0") == summary_text
+
+
+def test_exception_handler_lookup():
+    class CustomError(Exception):
+        pass
+
+    class CustomServerError(ServerError):
+        pass
+
+    def custom_error_handler():
+        pass
+
+    def server_error_handler():
+        pass
+
+    def import_error_handler():
+        pass
+
+    try:
+        ModuleNotFoundError
+    except:
+        class ModuleNotFoundError(ImportError):
+            pass
+
+    handler = ErrorHandler()
+    handler.add(ImportError, import_error_handler)
+    handler.add(CustomError, custom_error_handler)
+    handler.add(ServerError, server_error_handler)
+
+    assert handler.lookup(ImportError()) == import_error_handler
+    assert handler.lookup(ModuleNotFoundError()) == import_error_handler
+    assert handler.lookup(CustomError()) == custom_error_handler
+    assert handler.lookup(ServerError('Error')) == server_error_handler
+    assert handler.lookup(CustomServerError('Error')) == server_error_handler
+
+    # once again to ensure there is no caching bug
+    assert handler.lookup(ImportError()) == import_error_handler
+    assert handler.lookup(ModuleNotFoundError()) == import_error_handler
+    assert handler.lookup(CustomError()) == custom_error_handler
+    assert handler.lookup(ServerError('Error')) == server_error_handler
+    assert handler.lookup(CustomServerError('Error')) == server_error_handler

tests/test_logging.py

@@ -1,5 +1,7 @@
-import asyncio
 import uuid
+from importlib import reload
+
+from sanic.config import LOGGING
 from sanic.response import text
 from sanic import Sanic
 from io import StringIO
@@ -10,6 +12,11 @@ function: %(funcName)s(); \
 message: %(message)s'''
 
 
+def reset_logging():
+    logging.shutdown()
+    reload(logging)
+
+
 def test_log():
     log_stream = StringIO()
     for handler in logging.root.handlers[:]:
@@ -32,5 +39,19 @@ def test_log():
     log_text = log_stream.getvalue()
     assert rand_string in log_text
 
+
+def test_default_log_fmt():
+
+    reset_logging()
+    Sanic()
+    for fmt in [h.formatter for h in logging.getLogger('sanic').handlers]:
+        assert fmt._fmt == LOGGING['formatters']['simple']['format']
+
+    reset_logging()
+    Sanic(log_config=None)
+    for fmt in [h.formatter for h in logging.getLogger('sanic').handlers]:
+        assert fmt._fmt == "%(asctime)s: %(levelname)s: %(message)s"
+
+
 if __name__ == "__main__":
     test_log()

tests/test_middleware.py

@@ -2,6 +2,7 @@ from json import loads as json_loads, dumps as json_dumps
 from sanic import Sanic
 from sanic.request import Request
 from sanic.response import json, text, HTTPResponse
+from sanic.exceptions import NotFound
 
 
 # ------------------------------------------------------------ #
@@ -53,6 +54,27 @@ def test_middleware_response():
     assert isinstance(results[2], HTTPResponse)
 
 
+def test_middleware_response_exception():
+    app = Sanic('test_middleware_response_exception')
+    result = {'status_code': None}
+
+    @app.middleware('response')
+    async def process_response(reqest, response):
+        result['status_code'] = response.status
+        return response
+
+    @app.exception(NotFound)
+    async def error_handler(request, exception):
+        return text('OK', exception.status_code)
+
+    @app.route('/')
+    async def handler(request):
+        return text('FAIL')
+
+    request, response = app.test_client.get('/page_not_found')
+    assert response.text == 'OK'
+    assert result['status_code'] == 404
+
 def test_middleware_override_request():
     app = Sanic('test_middleware_override_request')
 

tests/test_payload_too_large.py

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

tests/test_redirect.py

@@ -88,4 +88,7 @@ def test_chained_redirect(redirect_app):
     assert request.url.endswith('/1')
     assert response.status == 200
     assert response.text == 'OK'
-    assert response.url.endswith('/3')
+    try:
+        assert response.url.endswith('/3')
+    except AttributeError:
+        assert response.url.path.endswith('/3')

tests/test_request_data.py

@@ -2,7 +2,11 @@ import random
 
 from sanic import Sanic
 from sanic.response import json
-from ujson import loads
+
+try:
+    from ujson import loads
+except ImportError:
+    from json import loads
 
 
 def test_storage():

tests/test_request_stream.py

@@ -0,0 +1,463 @@
+import asyncio
+from sanic import Sanic
+from sanic.blueprints import Blueprint
+from sanic.views import CompositionView
+from sanic.views import HTTPMethodView
+from sanic.views import stream as stream_decorator
+from sanic.response import stream, text
+
+data = "abc" * 100000
+
+
+def test_request_stream_method_view():
+    '''for self.is_request_stream = True'''
+
+    app = Sanic('test_request_stream_method_view')
+
+    class SimpleView(HTTPMethodView):
+
+        def get(self, request):
+            assert request.stream is None
+            return text('OK')
+
+        @stream_decorator
+        async def post(self, request):
+            assert isinstance(request.stream, asyncio.Queue)
+            result = ''
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                result += body.decode('utf-8')
+            return text(result)
+
+    app.add_route(SimpleView.as_view(), '/method_view')
+
+    assert app.is_request_stream is True
+
+    request, response = app.test_client.get('/method_view')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/method_view', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+
+def test_request_stream_app():
+    '''for self.is_request_stream = True and decorators'''
+
+    app = Sanic('test_request_stream_app')
+
+    @app.get('/get')
+    async def get(request):
+        assert request.stream is None
+        return text('GET')
+
+    @app.head('/head')
+    async def head(request):
+        assert request.stream is None
+        return text('HEAD')
+
+    @app.delete('/delete')
+    async def delete(request):
+        assert request.stream is None
+        return text('DELETE')
+
+    @app.options('/options')
+    async def options(request):
+        assert request.stream is None
+        return text('OPTIONS')
+
+    @app.post('/_post/<id>')
+    async def _post(request, id):
+        assert request.stream is None
+        return text('_POST')
+
+    @app.post('/post/<id>', stream=True)
+    async def post(request, id):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    @app.put('/_put')
+    async def _put(request):
+        assert request.stream is None
+        return text('_PUT')
+
+    @app.put('/put', stream=True)
+    async def put(request):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    @app.patch('/_patch')
+    async def _patch(request):
+        assert request.stream is None
+        return text('_PATCH')
+
+    @app.patch('/patch', stream=True)
+    async def patch(request):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    assert app.is_request_stream is True
+
+    request, response = app.test_client.get('/get')
+    assert response.status == 200
+    assert response.text == 'GET'
+
+    request, response = app.test_client.head('/head')
+    assert response.status == 200
+    assert response.text == ''
+
+    request, response = app.test_client.delete('/delete')
+    assert response.status == 200
+    assert response.text == 'DELETE'
+
+    request, response = app.test_client.options('/options')
+    assert response.status == 200
+    assert response.text == 'OPTIONS'
+
+    request, response = app.test_client.post('/_post/1', data=data)
+    assert response.status == 200
+    assert response.text == '_POST'
+
+    request, response = app.test_client.post('/post/1', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.put('/_put', data=data)
+    assert response.status == 200
+    assert response.text == '_PUT'
+
+    request, response = app.test_client.put('/put', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.patch('/_patch', data=data)
+    assert response.status == 200
+    assert response.text == '_PATCH'
+
+    request, response = app.test_client.patch('/patch', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+
+def test_request_stream_handle_exception():
+    '''for handling exceptions properly'''
+
+    app = Sanic('test_request_stream_exception')
+
+    @app.post('/post/<id>', stream=True)
+    async def post(request, id):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    # 404
+    request, response = app.test_client.post('/in_valid_post', data=data)
+    assert response.status == 404
+    assert response.text == 'Error: Requested URL /in_valid_post not found'
+
+    # 405
+    request, response = app.test_client.get('/post/random_id', data=data)
+    assert response.status == 405
+    assert response.text == 'Error: Method GET not allowed for URL /post/random_id'
+
+
+def test_request_stream_blueprint():
+    '''for self.is_request_stream = True'''
+
+    app = Sanic('test_request_stream_blueprint')
+    bp = Blueprint('test_blueprint_request_stream_blueprint')
+
+    @app.get('/get')
+    async def get(request):
+        assert request.stream is None
+        return text('GET')
+
+    @bp.head('/head')
+    async def head(request):
+        assert request.stream is None
+        return text('HEAD')
+
+    @bp.delete('/delete')
+    async def delete(request):
+        assert request.stream is None
+        return text('DELETE')
+
+    @bp.options('/options')
+    async def options(request):
+        assert request.stream is None
+        return text('OPTIONS')
+
+    @bp.post('/_post/<id>')
+    async def _post(request, id):
+        assert request.stream is None
+        return text('_POST')
+
+    @bp.post('/post/<id>', stream=True)
+    async def post(request, id):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    @bp.put('/_put')
+    async def _put(request):
+        assert request.stream is None
+        return text('_PUT')
+
+    @bp.put('/put', stream=True)
+    async def put(request):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    @bp.patch('/_patch')
+    async def _patch(request):
+        assert request.stream is None
+        return text('_PATCH')
+
+    @bp.patch('/patch', stream=True)
+    async def patch(request):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    app.blueprint(bp)
+
+    assert app.is_request_stream is True
+
+    request, response = app.test_client.get('/get')
+    assert response.status == 200
+    assert response.text == 'GET'
+
+    request, response = app.test_client.head('/head')
+    assert response.status == 200
+    assert response.text == ''
+
+    request, response = app.test_client.delete('/delete')
+    assert response.status == 200
+    assert response.text == 'DELETE'
+
+    request, response = app.test_client.options('/options')
+    assert response.status == 200
+    assert response.text == 'OPTIONS'
+
+    request, response = app.test_client.post('/_post/1', data=data)
+    assert response.status == 200
+    assert response.text == '_POST'
+
+    request, response = app.test_client.post('/post/1', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.put('/_put', data=data)
+    assert response.status == 200
+    assert response.text == '_PUT'
+
+    request, response = app.test_client.put('/put', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.patch('/_patch', data=data)
+    assert response.status == 200
+    assert response.text == '_PATCH'
+
+    request, response = app.test_client.patch('/patch', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+
+def test_request_stream_composition_view():
+    '''for self.is_request_stream = True'''
+
+    app = Sanic('test_request_stream__composition_view')
+
+    def get_handler(request):
+        assert request.stream is None
+        return text('OK')
+
+    async def post_handler(request):
+        assert isinstance(request.stream, asyncio.Queue)
+        result = ''
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            result += body.decode('utf-8')
+        return text(result)
+
+    view = CompositionView()
+    view.add(['GET'], get_handler)
+    view.add(['POST'], post_handler, stream=True)
+    app.add_route(view, '/composition_view')
+
+    assert app.is_request_stream is True
+
+    request, response = app.test_client.get('/composition_view')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/composition_view', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+
+def test_request_stream():
+    '''test for complex application'''
+
+    bp = Blueprint('test_blueprint_request_stream')
+    app = Sanic('test_request_stream')
+
+    class SimpleView(HTTPMethodView):
+
+        def get(self, request):
+            assert request.stream is None
+            return text('OK')
+
+        @stream_decorator
+        async def post(self, request):
+            assert isinstance(request.stream, asyncio.Queue)
+            result = ''
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                result += body.decode('utf-8')
+            return text(result)
+
+    @app.post('/stream', stream=True)
+    async def handler(request):
+        assert isinstance(request.stream, asyncio.Queue)
+
+        async def streaming(response):
+            while True:
+                body = await request.stream.get()
+                if body is None:
+                    break
+                response.write(body.decode('utf-8'))
+        return stream(streaming)
+
+    @app.get('/get')
+    async def get(request):
+        assert request.stream is None
+        return text('OK')
+
+    @bp.post('/bp_stream', stream=True)
+    async def bp_stream(request):
+        assert isinstance(request.stream, asyncio.Queue)
+        result = ''
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            result += body.decode('utf-8')
+        return text(result)
+
+    @bp.get('/bp_get')
+    async def bp_get(request):
+        assert request.stream is None
+        return text('OK')
+
+    def get_handler(request):
+        assert request.stream is None
+        return text('OK')
+
+    async def post_handler(request):
+        assert isinstance(request.stream, asyncio.Queue)
+        result = ''
+        while True:
+            body = await request.stream.get()
+            if body is None:
+                break
+            result += body.decode('utf-8')
+        return text(result)
+
+    app.add_route(SimpleView.as_view(), '/method_view')
+
+    view = CompositionView()
+    view.add(['GET'], get_handler)
+    view.add(['POST'], post_handler, stream=True)
+
+    app.blueprint(bp)
+
+    app.add_route(view, '/composition_view')
+
+    assert app.is_request_stream is True
+
+    request, response = app.test_client.get('/method_view')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/method_view', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.get('/composition_view')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/composition_view', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.get('/get')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/stream', data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = app.test_client.get('/bp_get')
+    assert response.status == 200
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/bp_stream', data=data)
+    assert response.status == 200
+    assert response.text == data

tests/test_requests.py

@@ -1,10 +1,15 @@
 from json import loads as json_loads, dumps as json_dumps
+from urllib.parse import urlparse
+import os
+import ssl
 
 import pytest
 
 from sanic import Sanic
 from sanic.exceptions import ServerError
-from sanic.response import json, text, redirect
+from sanic.response import json, text
+from sanic.request import DEFAULT_HTTP_CONTENT_TYPE
+from sanic.testing import HOST, PORT
 
 
 # ------------------------------------------------------------ #
@@ -85,20 +90,28 @@ def test_json():
 
     request, response = app.test_client.get('/')
 
-    try:
-        results = json_loads(response.text)
-    except:
-        raise ValueError("Expected JSON response but got '{}'".format(response))
+    results = json_loads(response.text)
 
     assert results.get('test') == True
 
+def test_empty_json():
+    app = Sanic('test_json')
+
+    @app.route('/')
+    async def handler(request):
+        assert request.json == None
+        return json(request.json)
+
+    request, response = app.test_client.get('/')
+    assert response.status == 200
+    assert response.text == 'null'
 
 def test_invalid_json():
     app = Sanic('test_json')
 
     @app.route('/')
     async def handler(request):
-        return json(request.json())
+        return json(request.json)
 
     data = "I am not json"
     request, response = app.test_client.get('/', data=data)
@@ -120,6 +133,17 @@ def test_query_string():
     assert request.args.get('test2') == 'false'
 
 
+def test_uri_template():
+    app = Sanic('test_uri_template')
+
+    @app.route('/foo/<id:int>/bar/<name:[A-z]+>')
+    async def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.get('/foo/123/bar/baz')
+    assert request.uri_template == '/foo/<id:int>/bar/<name:[A-z]+>'
+
+
 def test_token():
     app = Sanic('test_post_token')
 
@@ -128,6 +152,16 @@ def test_token():
         return text('OK')
 
     # uuid4 generated token.
+    token = 'a1d895e0-553a-421a-8e22-5ff8ecb48cbf'
+    headers = {
+        'content-type': 'application/json',
+        'Authorization': '{}'.format(token)
+    }
+
+    request, response = app.test_client.get('/', headers=headers)
+
+    assert request.token == token
+
     token = 'a1d895e0-553a-421a-8e22-5ff8ecb48cbf'
     headers = {
         'content-type': 'application/json',
@@ -138,6 +172,84 @@ def test_token():
 
     assert request.token == token
 
+    token = 'a1d895e0-553a-421a-8e22-5ff8ecb48cbf'
+    headers = {
+        'content-type': 'application/json',
+        'Authorization': 'Bearer {}'.format(token)
+    }
+
+    request, response = app.test_client.get('/', headers=headers)
+
+    assert request.token == token
+
+    # no Authorization headers
+    headers = {
+        'content-type': 'application/json'
+    }
+
+    request, response = app.test_client.get('/', headers=headers)
+
+    assert request.token is None
+
+
+def test_content_type():
+    app = Sanic('test_content_type')
+
+    @app.route('/')
+    async def handler(request):
+        return text(request.content_type)
+
+    request, response = app.test_client.get('/')
+    assert request.content_type == DEFAULT_HTTP_CONTENT_TYPE
+    assert response.text == DEFAULT_HTTP_CONTENT_TYPE
+
+    headers = {
+        'content-type': 'application/json',
+    }
+    request, response = app.test_client.get('/', headers=headers)
+    assert request.content_type == 'application/json'
+    assert response.text == 'application/json'
+
+
+def test_remote_addr():
+    app = Sanic('test_content_type')
+
+    @app.route('/')
+    async def handler(request):
+        return text(request.remote_addr)
+
+    headers = {
+        'X-Forwarded-For': '127.0.0.1, 127.0.1.2'
+    }
+    request, response = app.test_client.get('/', headers=headers)
+    assert request.remote_addr == '127.0.0.1'
+    assert response.text == '127.0.0.1'
+
+    request, response = app.test_client.get('/')
+    assert request.remote_addr == ''
+    assert response.text == ''
+
+    headers = {
+        'X-Forwarded-For': '127.0.0.1, ,   ,,127.0.1.2'
+    }
+    request, response = app.test_client.get('/', headers=headers)
+    assert request.remote_addr == '127.0.0.1'
+    assert response.text == '127.0.0.1'
+
+
+def test_match_info():
+    app = Sanic('test_match_info')
+
+    @app.route('/api/v1/user/<user_id>/')
+    async def handler(request, user_id):
+        return json(request.match_info)
+
+    request, response = app.test_client.get('/api/v1/user/sanic_user/')
+
+    assert request.match_info == {"user_id": "sanic_user"}
+    assert json_loads(response.text) == {"user_id": "sanic_user"}
+
+
 # ------------------------------------------------------------ #
 #  POST
 # ------------------------------------------------------------ #
@@ -174,21 +286,86 @@ def test_post_form_urlencoded():
     assert request.form.get('test') == 'OK'
 
 
-def test_post_form_multipart_form_data():
+@pytest.mark.parametrize(
+    'payload', [
+        '------sanic\r\n' \
+        'Content-Disposition: form-data; name="test"\r\n' \
+        '\r\n' \
+        'OK\r\n' \
+        '------sanic--\r\n',
+        '------sanic\r\n' \
+        'content-disposition: form-data; name="test"\r\n' \
+        '\r\n' \
+        'OK\r\n' \
+        '------sanic--\r\n',
+    ])
+def test_post_form_multipart_form_data(payload):
     app = Sanic('test_post_form_multipart_form_data')
 
     @app.route('/', methods=['POST'])
     async def handler(request):
         return text('OK')
 
-    payload = '------sanic\r\n' \
-              'Content-Disposition: form-data; name="test"\r\n' \
-              '\r\n' \
-              'OK\r\n' \
-              '------sanic--\r\n'
-
     headers = {'content-type': 'multipart/form-data; boundary=----sanic'}
 
     request, response = app.test_client.post(data=payload, headers=headers)
 
     assert request.form.get('test') == 'OK'
+
+
+@pytest.mark.parametrize(
+    'path,query,expected_url', [
+        ('/foo', '', 'http://{}:{}/foo'),
+        ('/bar/baz', '', 'http://{}:{}/bar/baz'),
+        ('/moo/boo', 'arg1=val1', 'http://{}:{}/moo/boo?arg1=val1')
+    ])
+def test_url_attributes_no_ssl(path, query, expected_url):
+    app = Sanic('test_url_attrs_no_ssl')
+
+    async def handler(request):
+        return text('OK')
+
+    app.add_route(handler, path)
+
+    request, response = app.test_client.get(path + '?{}'.format(query))
+    assert request.url == expected_url.format(HOST, PORT)
+
+    parsed = urlparse(request.url)
+
+    assert parsed.scheme == request.scheme
+    assert parsed.path == request.path
+    assert parsed.query == request.query_string
+    assert parsed.netloc == request.host
+
+
+@pytest.mark.parametrize(
+    'path,query,expected_url', [
+        ('/foo', '', 'https://{}:{}/foo'),
+        ('/bar/baz', '', 'https://{}:{}/bar/baz'),
+        ('/moo/boo', 'arg1=val1', 'https://{}:{}/moo/boo?arg1=val1')
+    ])
+def test_url_attributes_with_ssl(path, query, expected_url):
+    app = Sanic('test_url_attrs_with_ssl')
+
+    current_dir = os.path.dirname(os.path.realpath(__file__))
+    context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
+    context.load_cert_chain(
+        os.path.join(current_dir, 'certs/selfsigned.cert'),
+        keyfile=os.path.join(current_dir, 'certs/selfsigned.key'))
+
+    async def handler(request):
+        return text('OK')
+
+    app.add_route(handler, path)
+
+    request, response = app.test_client.get(
+        'https://{}:{}'.format(HOST, PORT) + path + '?{}'.format(query),
+        server_kwargs={'ssl': context})
+    assert request.url == expected_url.format(HOST, PORT)
+
+    parsed = urlparse(request.url)
+
+    assert parsed.scheme == request.scheme
+    assert parsed.path == request.path
+    assert parsed.query == request.query_string
+    assert parsed.netloc == request.host

tests/test_response.py

@@ -1,7 +1,20 @@
+import asyncio
+import inspect
+import os
+from aiofiles import os as async_os
+from mimetypes import guess_type
+from urllib.parse import unquote
+
+import pytest
 from random import choice
 
 from sanic import Sanic
-from sanic.response import HTTPResponse
+from sanic.response import HTTPResponse, stream, StreamingHTTPResponse, file, file_stream, json
+from sanic.testing import HOST, PORT
+from unittest.mock import MagicMock
+
+JSON_DATA = {'ok': True}
+
 
 
 def test_response_body_not_a_string():
@@ -15,3 +28,200 @@ def test_response_body_not_a_string():
 
     request, response = app.test_client.get('/hello')
     assert response.text == str(random_num)
+
+
+async def sample_streaming_fn(response):
+    response.write('foo,')
+    await asyncio.sleep(.001)
+    response.write('bar')
+
+
+@pytest.fixture
+def json_app():
+    app = Sanic('json')
+
+    @app.route("/")
+    async def test(request):
+        return json(JSON_DATA)
+
+    return app
+
+
+def test_json_response(json_app):
+    from sanic.response import json_dumps
+    request, response = json_app.test_client.get('/')
+    assert response.status == 200
+    assert response.text == json_dumps(JSON_DATA)
+    assert response.json == JSON_DATA
+
+@pytest.fixture
+def streaming_app():
+    app = Sanic('streaming')
+
+    @app.route("/")
+    async def test(request):
+        return stream(sample_streaming_fn, content_type='text/csv')
+
+    return app
+
+
+def test_streaming_adds_correct_headers(streaming_app):
+    request, response = streaming_app.test_client.get('/')
+    assert response.headers['Transfer-Encoding'] == 'chunked'
+    assert response.headers['Content-Type'] == 'text/csv'
+
+
+def test_streaming_returns_correct_content(streaming_app):
+    request, response = streaming_app.test_client.get('/')
+    assert response.text == 'foo,bar'
+
+
+@pytest.mark.parametrize('status', [200, 201, 400, 401])
+def test_stream_response_status_returns_correct_headers(status):
+    response = StreamingHTTPResponse(sample_streaming_fn, status=status)
+    headers = response.get_headers()
+    assert b"HTTP/1.1 %s" % str(status).encode() in headers
+
+
+@pytest.mark.parametrize('keep_alive_timeout', [10, 20, 30])
+def test_stream_response_keep_alive_returns_correct_headers(
+        keep_alive_timeout):
+    response = StreamingHTTPResponse(sample_streaming_fn)
+    headers = response.get_headers(
+        keep_alive=True, keep_alive_timeout=keep_alive_timeout)
+
+    assert b"Keep-Alive: %s\r\n" % str(keep_alive_timeout).encode() in headers
+
+
+def test_stream_response_includes_chunked_header():
+    response = StreamingHTTPResponse(sample_streaming_fn)
+    headers = response.get_headers()
+    assert b"Transfer-Encoding: chunked\r\n" in headers
+
+
+def test_stream_response_writes_correct_content_to_transport(streaming_app):
+    response = StreamingHTTPResponse(sample_streaming_fn)
+    response.transport = MagicMock(asyncio.Transport)
+
+    @streaming_app.listener('after_server_start')
+    async def run_stream(app, loop):
+        await response.stream()
+        assert response.transport.write.call_args_list[1][0][0] == (
+            b'4\r\nfoo,\r\n'
+        )
+
+        assert response.transport.write.call_args_list[2][0][0] == (
+            b'3\r\nbar\r\n'
+        )
+
+        assert response.transport.write.call_args_list[3][0][0] == (
+            b'0\r\n\r\n'
+        )
+
+        app.stop()
+
+    streaming_app.run(host=HOST, port=PORT)
+
+
+@pytest.fixture
+def static_file_directory():
+    """The static directory to serve"""
+    current_file = inspect.getfile(inspect.currentframe())
+    current_directory = os.path.dirname(os.path.abspath(current_file))
+    static_directory = os.path.join(current_directory, 'static')
+    return static_directory
+
+
+def get_file_content(static_file_directory, file_name):
+    """The content of the static file to check"""
+    with open(os.path.join(static_file_directory, file_name), 'rb') as file:
+        return file.read()
+
+@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt', 'python.png'])
+def test_file_response(file_name, static_file_directory):
+    app = Sanic('test_file_helper')
+    @app.route('/files/<filename>', methods=['GET'])
+    def file_route(request, filename):
+        file_path = os.path.join(static_file_directory, filename)
+        file_path = os.path.abspath(unquote(file_path))
+        return file(file_path, mime_type=guess_type(file_path)[0] or 'text/plain')
+
+    request, response = app.test_client.get('/files/{}'.format(file_name))
+    assert response.status == 200
+    assert response.body == get_file_content(static_file_directory, file_name)
+
+
+@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt'])
+def test_file_head_response(file_name, static_file_directory):
+    app = Sanic('test_file_helper')
+    @app.route('/files/<filename>', methods=['GET', 'HEAD'])
+    async def file_route(request, filename):
+        file_path = os.path.join(static_file_directory, filename)
+        file_path = os.path.abspath(unquote(file_path))
+        stats = await async_os.stat(file_path)
+        headers = dict()
+        headers['Accept-Ranges'] = 'bytes'
+        headers['Content-Length'] = str(stats.st_size)
+        if request.method == "HEAD":
+            return HTTPResponse(
+                headers=headers,
+                content_type=guess_type(file_path)[0] or 'text/plain')
+        else:
+            return file(file_path, headers=headers,
+                        mime_type=guess_type(file_path)[0] or 'text/plain')
+
+    request, response = app.test_client.head('/files/{}'.format(file_name))
+    assert response.status == 200
+    assert 'Accept-Ranges' in response.headers
+    assert 'Content-Length' in response.headers
+    assert int(response.headers[
+               'Content-Length']) == len(
+                   get_file_content(static_file_directory, file_name))
+
+@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt', 'python.png'])
+def test_file_stream_response(file_name, static_file_directory):
+    app = Sanic('test_file_helper')
+    @app.route('/files/<filename>', methods=['GET'])
+    def file_route(request, filename):
+        file_path = os.path.join(static_file_directory, filename)
+        file_path = os.path.abspath(unquote(file_path))
+        return file_stream(file_path, chunk_size=32,
+                          mime_type=guess_type(file_path)[0] or 'text/plain')
+
+    request, response = app.test_client.get('/files/{}'.format(file_name))
+    assert response.status == 200
+    assert response.body == get_file_content(static_file_directory, file_name)
+
+
+@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt'])
+def test_file_stream_head_response(file_name, static_file_directory):
+    app = Sanic('test_file_helper')
+    @app.route('/files/<filename>', methods=['GET', 'HEAD'])
+    async def file_route(request, filename):
+        file_path = os.path.join(static_file_directory, filename)
+        file_path = os.path.abspath(unquote(file_path))
+        headers = dict()
+        headers['Accept-Ranges'] = 'bytes'
+        if request.method == "HEAD":
+            # Return a normal HTTPResponse, not a
+            # StreamingHTTPResponse for a HEAD request
+            stats = await async_os.stat(file_path)
+            headers['Content-Length'] = str(stats.st_size)
+            return HTTPResponse(
+                headers=headers,
+                content_type=guess_type(file_path)[0] or 'text/plain')
+        else:
+            return file_stream(file_path, chunk_size=32, headers=headers,
+                        mime_type=guess_type(file_path)[0] or 'text/plain')
+
+    request, response = app.test_client.head('/files/{}'.format(file_name))
+    assert response.status == 200
+    # A HEAD request should never be streamed/chunked.
+    if 'Transfer-Encoding' in response.headers:
+        assert response.headers['Transfer-Encoding'] != "chunked"
+    assert 'Accept-Ranges' in response.headers
+    # A HEAD request should get the Content-Length too
+    assert 'Content-Length' in response.headers
+    assert int(response.headers[
+               'Content-Length']) == len(
+                   get_file_content(static_file_directory, file_name))

tests/test_routes.py

@@ -1,14 +1,36 @@
+import asyncio
 import pytest
 
 from sanic import Sanic
 from sanic.response import text
 from sanic.router import RouteExists, RouteDoesNotExist
+from sanic.constants import HTTP_METHODS
 
 
 # ------------------------------------------------------------ #
 #  UTF-8
 # ------------------------------------------------------------ #
 
+@pytest.mark.parametrize('method', HTTP_METHODS)
+def test_versioned_routes_get(method):
+    app = Sanic('test_shorhand_routes_get')
+
+    method = method.lower()
+
+    func = getattr(app, method)
+    if callable(func):
+        @func('/{}'.format(method), version=1)
+        def handler(request):
+            return text('OK')
+    else:
+        print(func)
+        raise
+
+    client_method = getattr(app.test_client, method)
+
+    request, response = client_method('/v1/{}'.format(method))
+    assert response.status== 200
+
 def test_shorthand_routes_get():
     app = Sanic('test_shorhand_routes_get')
 
@@ -22,6 +44,33 @@ def test_shorthand_routes_get():
     request, response = app.test_client.post('/get')
     assert response.status == 405
 
+def test_route_strict_slash():
+    app = Sanic('test_route_strict_slash')
+
+    @app.get('/get', strict_slashes=True)
+    def handler(request):
+        assert request.stream is None
+        return text('OK')
+
+    @app.post('/post/', strict_slashes=True)
+    def handler(request):
+        assert request.stream is None
+        return text('OK')
+
+    assert app.is_request_stream is False
+
+    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_route_optional_slash():
     app = Sanic('test_route_optional_slash')
 
@@ -53,21 +102,43 @@ def test_shorthand_routes_put():
 
     @app.put('/put')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
+    assert app.is_request_stream is False
+
     request, response = app.test_client.put('/put')
     assert response.text == 'OK'
 
     request, response = app.test_client.get('/put')
     assert response.status == 405
 
+def test_shorthand_routes_delete():
+    app = Sanic('test_shorhand_routes_delete')
+
+    @app.delete('/delete')
+    def handler(request):
+        assert request.stream is None
+        return text('OK')
+
+    assert app.is_request_stream is False
+
+    request, response = app.test_client.delete('/delete')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/delete')
+    assert response.status == 405
+
 def test_shorthand_routes_patch():
     app = Sanic('test_shorhand_routes_patch')
 
     @app.patch('/patch')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
+    assert app.is_request_stream is False
+
     request, response = app.test_client.patch('/patch')
     assert response.text == 'OK'
 
@@ -79,8 +150,11 @@ def test_shorthand_routes_head():
 
     @app.head('/head')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
+    assert app.is_request_stream is False
+
     request, response = app.test_client.head('/head')
     assert response.status == 200
 
@@ -92,8 +166,11 @@ def test_shorthand_routes_options():
 
     @app.options('/options')
     def handler(request):
+        assert request.stream is None
         return text('OK')
 
+    assert app.is_request_stream is False
+
     request, response = app.test_client.options('/options')
     assert response.status == 200
 
@@ -214,6 +291,30 @@ def test_dynamic_route_regex():
     assert response.status == 200
 
 
+def test_dynamic_route_path():
+    app = Sanic('test_dynamic_route_path')
+
+    @app.route('/<path:path>/info')
+    async def handler(request, path):
+        return text('OK')
+
+    request, response = app.test_client.get('/path/1/info')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/info')
+    assert response.status == 404
+
+    @app.route('/<path:path>')
+    async def handler1(request, path):
+        return text('OK')
+
+    request, response = app.test_client.get('/info')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/whatever/you/set')
+    assert response.status == 200
+
+
 def test_dynamic_route_unhashable():
     app = Sanic('test_dynamic_route_unhashable')
 
@@ -234,6 +335,23 @@ def test_dynamic_route_unhashable():
     assert response.status == 404
 
 
+def test_websocket_route():
+    app = Sanic('test_websocket_route')
+    ev = asyncio.Event()
+
+    @app.websocket('/ws')
+    async def handler(request, ws):
+        ev.set()
+
+    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()
+
+
 def test_route_duplicate():
     app = Sanic('test_route_duplicate')
 

tests/test_static.py

@@ -25,7 +25,7 @@ def get_file_content(static_file_directory, file_name):
         return file.read()
 
 
-@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt'])
+@pytest.mark.parametrize('file_name', ['test.file', 'decode me.txt', 'python.png'])
 def test_static_file(static_file_directory, file_name):
     app = Sanic('test_static')
     app.static(