+1.2.0 (2016-12-17)

+- Extract `BaseRequest` from `web.Request`, introduce `web.Server`

+ (former `RequestHandlerFactory`), introduce new low-level web server

+ which is not coupled with `web.Application` and routing #1362

+- Implement range requests for static files #1382

+- Support task attribute for StreamResponse #1410

+- Drop `TestClient.app` property, use `TestClient.server.app` instead

+ (BACKWARD INCOMPATIBLE)

+- Drop `TestClient.handler` property, use `TestClient.server.handler` instead

+ (BACKWARD INCOMPATIBLE)

+- `TestClient.server` property returns a test server instance, was

+ `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE)

+- Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201

+- Call worker_int and worker_abort callbacks in

+ `Gunicorn[UVLoop]WebWorker` #1202

+- Has functional tests for client proxy #1218

+- Fix bugs with client proxy target path and proxy host with port #1413

+- Fix bugs related to the use of unicode hostnames #1444

+- Preserve cookie quoting/escaping #1453

+- FileSender will send gzipped response if gzip version available #1426

+- Don't override `Content-Length` header in `web.Response` if no body

+ was set #1400

+- Introduce `router.post_init()` for solving #1373

+- Fix raise error in case of multiple calls of `TimeServive.stop()`

+- Allow to raise web exceptions on router resolving stage #1460

+- Add a warning for session creation outside of coroutine #1468

+- Avoid a race when application might start accepting incoming requests

+ but startup signals are not processed yet e98e8c6

+- Raise a `RuntimeError` when trying to change the status of the HTTP response

+ after the headers have been sent #1480

+- Fix bug with https proxy acquired cleanup #1340

+- Use UTF-8 as the default encoding for multipart text parts #1484

+Alexander Mohr

+Andrew Leech

+Pahaz Blinov <pahaz.blinov@gmail.com>

+Paulus Schoutsen

+Rafael Viotti

+Serhii Kostel

+ @echo "Run without extensions"

+ @echo "Run in debug mode"

+ @echo "Regular run"

+Version: 1.2.0

+ 1.2.0 (2016-12-17)

+ - Extract `BaseRequest` from `web.Request`, introduce `web.Server`

+ (former `RequestHandlerFactory`), introduce new low-level web server

+ which is not coupled with `web.Application` and routing #1362

+ - Implement range requests for static files #1382

+ - Support task attribute for StreamResponse #1410

+ - Drop `TestClient.app` property, use `TestClient.server.app` instead

+ (BACKWARD INCOMPATIBLE)

+ - Drop `TestClient.handler` property, use `TestClient.server.handler` instead

+ (BACKWARD INCOMPATIBLE)

+ - `TestClient.server` property returns a test server instance, was

+ `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE)

+ - Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201

+ - Call worker_int and worker_abort callbacks in

+ `Gunicorn[UVLoop]WebWorker` #1202

+ - Has functional tests for client proxy #1218

+ - Fix bugs with client proxy target path and proxy host with port #1413

+ - Fix bugs related to the use of unicode hostnames #1444

+ - Preserve cookie quoting/escaping #1453

+ - FileSender will send gzipped response if gzip version available #1426

+ - Don't override `Content-Length` header in `web.Response` if no body

+ was set #1400

+ - Introduce `router.post_init()` for solving #1373

+ - Fix raise error in case of multiple calls of `TimeServive.stop()`

+ - Allow to raise web exceptions on router resolving stage #1460

+ - Add a warning for session creation outside of coroutine #1468

+ - Avoid a race when application might start accepting incoming requests

+ but startup signals are not processed yet e98e8c6

+ - Raise a `RuntimeError` when trying to change the status of the HTTP response

+ after the headers have been sent #1480

+ - Fix bug with https proxy acquired cleanup #1340

+ - Use UTF-8 as the default encoding for multipart text parts #1484

+Version: 1.2.0

+ 1.2.0 (2016-12-17)

+ - Extract `BaseRequest` from `web.Request`, introduce `web.Server`

+ (former `RequestHandlerFactory`), introduce new low-level web server

+ which is not coupled with `web.Application` and routing #1362

+ - Implement range requests for static files #1382

+ - Support task attribute for StreamResponse #1410

+ - Drop `TestClient.app` property, use `TestClient.server.app` instead

+ (BACKWARD INCOMPATIBLE)

+ - Drop `TestClient.handler` property, use `TestClient.server.handler` instead

+ (BACKWARD INCOMPATIBLE)

+ - `TestClient.server` property returns a test server instance, was

+ `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE)

+ - Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201

+ - Call worker_int and worker_abort callbacks in

+ `Gunicorn[UVLoop]WebWorker` #1202

+ - Has functional tests for client proxy #1218

+ - Fix bugs with client proxy target path and proxy host with port #1413

+ - Fix bugs related to the use of unicode hostnames #1444

+ - Preserve cookie quoting/escaping #1453

+ - FileSender will send gzipped response if gzip version available #1426

+ - Don't override `Content-Length` header in `web.Response` if no body

+ was set #1400

+ - Introduce `router.post_init()` for solving #1373

+ - Fix raise error in case of multiple calls of `TimeServive.stop()`

+ - Allow to raise web exceptions on router resolving stage #1460

+ - Add a warning for session creation outside of coroutine #1468

+ - Avoid a race when application might start accepting incoming requests

+ but startup signals are not processed yet e98e8c6

+ - Raise a `RuntimeError` when trying to change the status of the HTTP response

+ after the headers have been sent #1480

+ - Fix bug with https proxy acquired cleanup #1340

+ - Use UTF-8 as the default encoding for multipart text parts #1484

+aiohttp/web_server.py

+docs/web_lowlevel.rst

+examples/lowlevel_srv.py

+tests/test_proxy_functional.py

+tests/test_web_server.py

+multidict>=2.1.4

+yarl>=0.8.1

+__version__ = '1.2.0'

+/* Generated by Cython 0.25.2 */

+#define CYTHON_ABI "0_25_2"

+ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))

+#ifndef CYTHON_UNUSED

+# if defined(__GNUC__)

+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

+# define CYTHON_UNUSED __attribute__ ((__unused__))

+# else

+# define CYTHON_UNUSED

+# endif

+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))

+# define CYTHON_UNUSED __attribute__ ((__unused__))

+# else

+# define CYTHON_UNUSED

+# endif

+#endif

+#ifndef CYTHON_MAYBE_UNUSED_VAR

+# if defined(__cplusplus)

+ template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }

+# else

+# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)

+# endif

+#endif

+#ifndef CYTHON_NCP_UNUSED

+# if CYTHON_COMPILING_IN_CPYTHON

+# define CYTHON_NCP_UNUSED

+# else

+# define CYTHON_NCP_UNUSED CYTHON_UNUSED

+# endif

+#endif

+ #if defined(__clang__)

+ #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))

+ #elif defined(__GNUC__)

+ def post_init(self, app):

+ """Post init stage.

+

+ It's not an abstract method for sake of backward compatibility

+ but if router wans to be aware about application it should

+ override it.

+

+ """

+

+ if not loop.is_running():

+ warnings.warn("Creating a client session outside of coroutine is "

+ "a very dangerous idea", ResourceWarning,

+ stacklevel=2)

+ context = {'client_session': self,

+ 'message': 'Creating a client session outside '

+ 'of coroutine'}

+ if self._source_traceback is not None:

+ context['source_traceback'] = self._source_traceback

+ loop.call_exception_handler(context)

+

+ netloc = self.url.raw_host

+ # Preserve coded_value

+ mrsl_val = value.get(value.key, http.cookies.Morsel())

+ mrsl_val.set(value.key, value.value, value.coded_value)

+ c[name] = mrsl_val

+ # Specify request target:

+ # - CONNECT request must send authority form URI

+ # - not CONNECT proxy must send absolute form URI

+ # - most common is origin form URI

+ if self.method == hdrs.METH_CONNECT:

+ path = '{}:{}'.format(self.url.raw_host, self.url.port)

+ elif self.proxy and not self.ssl:

+ path = str(self.url)

+ else:

+ path = self.url.raw_path

+ if self.url.raw_query_string:

+ path += '?' + self.url.raw_query_string

+

+ warnings.warn("Deprecated, use .url_obj",

+ DeprecationWarning,

+ stacklevel=2)

+ if self._transport is not None:

+ self._connector._release_acquired(self._key, self._transport)

+ def _release_acquired(self, key, transport):

+ return None

+

+ return acquired

+

+ def _release(self, key, req, transport, protocol, *, should_close=False):

+ if self._closed:

+ # acquired connection is already released on connector closing

+ return

+

+ acquired = self._release_acquired(key, transport)

+

+ if self._limit is not None and acquired is not None:

+ if len(acquired) < self._limit:

+ headers={hdrs.HOST: req.headers[hdrs.HOST]},

+ proxy_req.url = req.url

+ try:

+ if resp.status != 200:

+ raise HttpProxyError(code=resp.status,

+ message=resp.reason)

+ rawsock = transport.get_extra_info('socket', default=None)

+ if rawsock is None:

+ raise RuntimeError(

+ "Transport does not expose socket instance")

+ # Duplicate the socket, so now we can close proxy transport

+ rawsock = rawsock.dup()

+ finally:

+ transport.close()

+

+ hostname = response_url.raw_host

+ hostname = request_url.raw_host or ""

+ # It's critical we use the Morsel so the coded_value

+ # (based on cookie version) is preserved

+ mrsl_val = cookie.get(cookie.key, Morsel())

+ mrsl_val.set(cookie.key, cookie.value, cookie.coded_value)

+ filtered[name] = mrsl_val

+from .web_exceptions import (HTTPNotModified, HTTPOk, HTTPPartialContent,

+ HTTPRequestRangeNotSatisfiable)

+ headers = ['HTTP/{0.major}.{0.minor} {1} OK\r\n'.format(

+ request.version, resp.status)]

+ offset = fobj.tell()

+ self._sendfile_cb(fut, out_fd, in_fd, offset, count, loop, False)

+ gzip = False

+ if 'gzip' in request.headers.get(hdrs.ACCEPT_ENCODING, ''):

+ gzip_path = filepath.with_name(filepath.name + '.gz')

+

+ if gzip_path.is_file():

+ filepath = gzip_path

+ gzip = True

+

+ status = HTTPOk.status_code

+ file_size = st.st_size

+ count = file_size

+

+ try:

+ rng = request.http_range

+ start = rng.start

+ end = rng.stop

+ except ValueError:

+ raise HTTPRequestRangeNotSatisfiable

+

+ # If a range request has been made, convert start, end slice notation

+ # into file pointer offset and count

+ if start is not None or end is not None:

+ status = HTTPPartialContent.status_code

+ if start is None and end < 0: # return tail of file

+ start = file_size + end

+ count = -end

+ else:

+ count = (end or file_size) - start

+

+ if start + count > file_size:

+ raise HTTPRequestRangeNotSatisfiable

+

+ resp = self._response_factory(status=status)

+ if gzip:

+ resp.headers[hdrs.VARY] = hdrs.ACCEPT_ENCODING

+ resp.content_length = count

+ if start:

+ f.seek(start)

+ yield from self._sendfile(request, resp, f, count)

+ if self._cb:

+ self._cb.cancel()

+ # see https://www.w3.org/TR/html5/forms.html#multipart/form-data-encoding-algorithm # NOQA

+ # and https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-send # NOQA

+ encoding = encoding or self.get_charset(default='utf-8')

+ @property

+ self._version >= HttpVersion11)

+ @property

+ self._version >= HttpVersion11 and

+from .test_utils import (RawTestServer, TestClient, TestServer, loop_context,

+ setup_test_loop, teardown_test_loop)

+def raw_test_server(loop):

+ servers = []

+

+ @asyncio.coroutine

+ def go(handler, **kwargs):

+ server = RawTestServer(handler, loop=loop)

+ yield from server.start_server(**kwargs)

+ servers.append(server)

+ return server

+

+ yield go

+

+ @asyncio.coroutine

+ def finalize():

+ while servers:

+ yield from servers.pop().close()

+

+ loop.run_until_complete(finalize())

+

+

+@pytest.yield_fixture

+ elif isinstance(__param, RawTestServer):

+ assert not args, "args should be empty"

+ assert __param._loop is loop, \

+ "TestServer is attached to other event loop"

+ client = TestClient(__param, **kwargs)

+ lingering_time=30,

+ lingering_timeout=5,

+ self._lingering_time = float(lingering_time)

+ self._lingering_timeout = float(lingering_timeout)

+ # we can not gracefully shutdown handler

+ # if we in process of reading request

+ self._reading_request = True

+ # slow request timer

+ with Timeout(max(self._slow_request_timeout,

+ self._keepalive_timeout), loop=self._loop):

+ message.method == hdrs.METH_CONNECT or

+ if not payload.is_eof():

+

+ if self._lingering_time:

+ self.transport.write_eof()

+ self.log_debug(

+ 'Start lingering close timer for %s sec.',

+ self._lingering_time)

+

+ end_time = self._loop.time() + self._lingering_time

+

+ with suppress(asyncio.TimeoutError,

+ errors.ClientDisconnectedError):

+ while self._loop.time() < end_time:

+ with Timeout(self._lingering_timeout,

+ loop=self._loop):

+ # read and ignore

+ yield from payload.readany()

+from abc import ABC, abstractmethod

+from .web import Application, Request, Server, UrlMappingMatchInfo

+class BaseTestServer(ABC):

+ def __init__(self, *, scheme=sentinel, host='127.0.0.1'):

+

+ handler = yield from self._make_factory(**kwargs)

+ self.server = yield from self._loop.create_server(handler,

+ @abstractmethod # pragma: no cover

+ @asyncio.coroutine

+ def _make_factory(self, **kwargs):

+ pass

+

+ @property

+ def started(self):

+ return self.server is not None

+

+ @property

+ def closed(self):

+ return self._closed

+

+ if self.started and not self.closed:

+ yield from self._close_hook()

+ @abstractmethod

+ @asyncio.coroutine

+ def _close_hook(self):

+ pass # pragma: no cover

+

+class TestServer(BaseTestServer):

+ def __init__(self, app, *, scheme=sentinel, host='127.0.0.1'):

+ self.app = app

+ self._loop = app.loop

+ super().__init__(scheme=scheme, host=host)

+

+ @asyncio.coroutine

+ def _make_factory(self, **kwargs):

+ yield from self.app.startup()

+ self.handler = self.app.make_handler(**kwargs)

+ return self.handler

+

+ @asyncio.coroutine

+ def _close_hook(self):

+ yield from self.app.shutdown()

+ yield from self.handler.shutdown()

+ yield from self.app.cleanup()

+

+

+class RawTestServer(BaseTestServer):

+ def __init__(self, handler,

+ *, loop=None, scheme=sentinel, host='127.0.0.1'):

+ if loop is None:

+ loop = asyncio.get_event_loop()

+ self._loop = loop

+ self._handler = handler

+ super().__init__(scheme=scheme, host=host)

+

+ @asyncio.coroutine

+ def _make_factory(self, **kwargs):

+ self.handler = Server(self._handler, loop=self._loop, **kwargs)

+ return self.handler

+

+ @asyncio.coroutine

+ def _close_hook(self):

+ return

+

+

+ if isinstance(app_or_server, BaseTestServer):

+ self._loop = self._server._loop

+ return self._server

+ """An internal aiohttp.ClientSession.

+ """Routes a request to tested http server.

+ test server.

+ The api corresponds to aiohttp.ClientSession.ws_connect.

+ task = mock.Mock()

+

+ time_service, task,

+from . import (hdrs, web_exceptions, web_reqrep, web_server, web_urldispatcher,

+ web_ws)

+from .helpers import FrozenList, sentinel

+from .web_server import Server

+ web_server.__all__ +

+ ('Application', 'HttpVersion', 'MsgType'))

+ router=None,

+ middlewares=(), debug=...):

+ router = web_urldispatcher.UrlDispatcher()

+ router.post_init(self)

+

+ if debug is ...:

+ debug = loop.get_debug()

+

+ self._secure_proxy_ssl_header = None

+ def make_handler(self, *, secure_proxy_ssl_header=None, **kwargs):

+ self._secure_proxy_ssl_header = secure_proxy_ssl_header

+ return Server(self._handle, request_factory=self._make_request,

+ debug=self.debug, loop=self.loop, **kwargs)

+ def _make_request(self, message, payload, protocol,

+ _cls=web_reqrep.Request):

+ return _cls(

+ message, payload,

+ protocol.transport, protocol.reader, protocol.writer,

+ protocol.time_service, protocol._request_handler,

+ secure_proxy_ssl_header=self._secure_proxy_ssl_header)

+

+ @asyncio.coroutine

+ def _handle(self, request):

+ match_info = yield from self._router.resolve(request)

+ assert isinstance(match_info, AbstractMatchInfo), match_info

+ match_info.add_app(self)

+ match_info.freeze()

+

+ resp = None

+ request._match_info = match_info

+ expect = request.headers.get(hdrs.EXPECT)

+ if expect:

+ resp = (

+ yield from match_info.expect_handler(request))

+

+ if resp is None:

+ handler = match_info.handler

+ for app in match_info.apps:

+ for factory in reversed(app.middlewares):

+ handler = yield from factory(app, handler)

+ resp = yield from handler(request)

+

+ assert isinstance(resp, web_reqrep.StreamResponse), \

+ ("Handler {!r} should return response instance, "

+ "got {!r} [middlewares {!r}]").format(

+ match_info.handler, type(resp),

+ [middleware for middleware in app.middlewares

+ for app in match_info.apps])

+ return resp

+

+ loop.run_until_complete(app.startup())

+ srv = loop.run_until_complete(loop.create_server(handler, host,

+ port, ssl=ssl_context,

+ backlog=backlog))

+ loop.run_until_complete(handler.shutdown(shutdown_timeout))

+import re

+from http.cookies import SimpleCookie

+ 'ContentCoding', 'BaseRequest', 'Request', 'StreamResponse', 'Response',

+class BaseRequest(collections.MutableMapping, HeadersMixin):

+ time_service, task, *,

+ self._task = task

+ return self.__class__(

+ self._task,

+ @property

+ return not self._message.should_close

+ parsed = SimpleCookie(raw)

+ def http_range(self, *, _RANGE=hdrs.RANGE):

+ """The content of Range HTTP header.

+

+ Return a slice instance.

+

+ """

+ rng = self.headers.get(_RANGE)

+ start, end = None, None

+ if rng is not None:

+ try:

+ pattern = r'^bytes=(\d*)-(\d*)$'

+ start, end = re.findall(pattern, rng)[0]

+ except IndexError: # pattern was not found in header

+ raise ValueError("range not in acceptible format")

+

+ end = int(end) if end else None

+ start = int(start) if start else None

+

+ if start is None and end is not None:

+ # end with no start is to return tail of content

+ end = -end

+

+ if start is not None and end is not None:

+ # end is inclusive in range header, exclusive for slice

+ end += 1

+

+ if start >= end:

+ raise ValueError('start cannot be after end')

+

+ if start is end is None: # No valid range supplied

+ raise ValueError('No start or end of range specified')

+ return slice(start, end, 1)

+

+ @property

+ @asyncio.coroutine

+ def _prepare_hook(self, response):

+ return

+ yield # pragma: no cover

+

+

+class Request(BaseRequest):

+

+ def __init__(self, *args, **kwargs):

+ super().__init__(*args, **kwargs)

+

+ # matchdict, route_name, handler

+ # or information about traversal lookup

+ self._match_info = None # initialized after route resolving

+

+ @property

+ def match_info(self):

+ """Result of route resolving."""

+ return self._match_info

+

+ @reify

+ def app(self):

+ """Application instance."""

+ return self._match_info.apps[-1]

+

+ @asyncio.coroutine

+ def _prepare_hook(self, response):

+ match_info = self._match_info

+ if match_info is None:

+ return

+ for app in match_info.apps:

+ yield from app.on_response_prepare.send(self, response)

+

+ self._cookies = SimpleCookie()

+ self._task = None

+

+ # TODO: optimize CIMultiDict extending

+ self._headers.setdefault(hdrs.CONTENT_TYPE, 'application/octet-stream')

+ self.set_status(status, reason)

+ def task(self):

+ return self._task

+

+ @property

+ if self.prepared:

+ raise RuntimeError("Cannot change the response status code after "

+ "the headers have been sent")

+ @property

+ def body_length(self):

+ return self._resp_impl.body_length

+

+ @property

+ def output_length(self):

+ return self._resp.impl.output_length

+

+ yield from request._prepare_hook(self)

+ def _start(self, request,

+ HttpVersion10=HttpVersion10,

+ HttpVersion11=HttpVersion11,

+ CONNECTION=hdrs.CONNECTION,

+ DATE=hdrs.DATE,

+ SERVER=hdrs.SERVER,

+ SET_COOKIE=hdrs.SET_COOKIE,

+ TRANSFER_ENCODING=hdrs.TRANSFER_ENCODING):

+ for cookie in self._cookies.values():

+ value = cookie.output(header='')[1:]

+ headers.add(SET_COOKIE, value)

+

+ resp_impl.chunked = True

+ headers[TRANSFER_ENCODING] = 'chunked'

+ headers.setdefault(DATE, request._time_service.strtime())

+ headers.setdefault(SERVER, resp_impl.SERVER_SOFTWARE)

+ if CONNECTION not in headers:

+ headers[CONNECTION] = 'keep-alive'

+ headers[CONNECTION] = 'close'

+ self._task = request._task

+ elif body is None and hdrs.CONTENT_LENGTH in headers:

+ self._body = None

+"""Low level HTTP server."""

+

+import asyncio

+import traceback

+from html import escape as html_escape

+

+from .helpers import TimeService

+from .server import ServerHttpProtocol

+from .web_exceptions import HTTPException, HTTPInternalServerError

+from .web_reqrep import BaseRequest

+

+__all__ = ('RequestHandler', 'Server')

+

+

+class RequestHandler(ServerHttpProtocol):

+ _request = None

+

+ def __init__(self, manager, **kwargs):

+ super().__init__(**kwargs)

+ self._manager = manager

+ self._request_factory = manager.request_factory

+ self._handler = manager.handler

+ self.time_service = manager.time_service

+

+ def __repr__(self):

+ if self._request is None:

+ meth = 'none'

+ path = 'none'

+ else:

+ meth = self._request.method

+ path = self._request.rel_url.raw_path

+ return "<{} {}:{} {}>".format(

+ self.__class__.__name__, meth, path,

+ 'connected' if self.transport is not None else 'disconnected')

+

+ def connection_made(self, transport):

+ super().connection_made(transport)

+

+ self._manager.connection_made(self, transport)

+

+ def connection_lost(self, exc):

+ self._manager.connection_lost(self, exc)

+

+ super().connection_lost(exc)

+ self._request_factory = None

+ self._manager = None

+ self.time_service = None

+ self._handler = None

+

+ @asyncio.coroutine

+ def handle_request(self, message, payload):

+ self._manager._requests_count += 1

+ if self.access_log:

+ now = self._loop.time()

+

+ request = self._request_factory(message, payload, self)

+ self._request = request

+

+ try:

+ try:

+ resp = yield from self._handler(request)

+ except HTTPException as exc:

+ resp = exc

+ except Exception as exc:

+ msg = "<h1>500 Internal Server Error</h1>"

+ if self.debug:

+ try:

+ tb = traceback.format_exc()

+ tb = html_escape(tb)

+ msg += '<br><h2>Traceback:</h2>\n<pre>'

+ msg += tb

+ msg += '</pre>'

+ except: # pragma: no cover

+ pass

+ else:

+ msg += "Server got itself in trouble"

+ msg = ("<html><head><title>500 Internal Server Error</title>"

+ "</head><body>" + msg + "</body></html>")

+ resp = HTTPInternalServerError(text=msg,

+ content_type='text/html')

+ self.logger.exception(

+ "Error handling request",

+ exc_info=exc)

+

+ yield from resp.prepare(request)

+ yield from resp.write_eof()

+ finally:

+ resp._task = None

+

+ # notify server about keep-alive

+ # assign to parent class attr

+ self._keepalive = resp._keep_alive

+

+ # Restore default state.

+ # Should be no-op if server code didn't touch these attributes.

+ self.writer.set_tcp_cork(False)

+ self.writer.set_tcp_nodelay(True)

+

+ # log access

+ if self.access_log:

+ self.log_access(message, None, resp, self._loop.time() - now)

+

+ # for repr

+ self._request = None

+

+

+class Server:

+

+ def __init__(self, handler, *, request_factory=None, loop=None, **kwargs):

+ if loop is None:

+ loop = asyncio.get_event_loop()

+ self._handler = handler

+ self._request_factory = request_factory or self._make_request

+ self._loop = loop

+ self._connections = {}

+ self._kwargs = kwargs

+ self._requests_count = 0

+ self._time_service = TimeService(self._loop)

+

+ @property

+ def requests_count(self):

+ """Number of processed requests."""

+ return self._requests_count

+

+ @property

+ def handler(self):

+ return self._handler

+

+ @property

+ def request_factory(self):

+ return self._request_factory

+

+ @property

+ def time_service(self):

+ return self._time_service

+

+ @property

+ def connections(self):

+ return list(self._connections.keys())

+

+ def connection_made(self, handler, transport):

+ self._connections[handler] = transport

+

+ def connection_lost(self, handler, exc=None):

+ if handler in self._connections:

+ del self._connections[handler]

+

+ def _make_request(self, message, payload, protocol):

+ return BaseRequest(

+ message, payload,

+ protocol.transport, protocol.reader, protocol.writer,

+ protocol.time_service, protocol._request_handler)

+

+ @asyncio.coroutine

+ def shutdown(self, timeout=None):

+ coros = [conn.shutdown(timeout) for conn in self._connections]

+ yield from asyncio.gather(*coros, loop=self._loop)

+ self._connections.clear()

+ self._time_service.stop()

+

+ finish_connections = shutdown

+

+ def __call__(self):

+ return RequestHandler(

+ self, loop=self._loop,

+ **self._kwargs)

+ def __init__(self):

+ self._app = None

+

+ def post_init(self, app):

+ assert app is not None

+ if self._app is None:

+ raise RuntimeError(".post_init() should be called before "

+ "first resource registering")

+import logging

+from aiohttp.web_server import Server

+from aiohttp.wsgi import WSGIServerHttpProtocol

+ self._notify_waiter = None

+ if hasattr(self.wsgi, 'startup'):

+ self.loop.run_until_complete(self.wsgi.startup())

+ if hasattr(self.wsgi, 'make_handler'):

+ return app.make_handler(

+ logger=self.log,

+ slow_request_timeout=self.cfg.timeout,

+ keepalive_timeout=self.cfg.keepalive,

+ access_log=self.log.access_log,

+ access_log_format=self._get_valid_log_format(

+ self.cfg.access_log_format))

+ else:

+ return WSGIServer(self.wsgi, self)

+ if hasattr(self.wsgi, 'shutdown'):

+ yield from self.wsgi.shutdown()

+ handler.shutdown(

+ if hasattr(self.wsgi, 'cleanup'):

+ yield from self.wsgi.cleanup()

+ yield from self._wait_next_notify()

+ def _wait_next_notify(self):

+ self._notify_waiter_done()

+

+ self._notify_waiter = waiter = asyncio.Future(loop=self.loop)

+ self.loop.call_later(1.0, self._notify_waiter_done)

+

+ return waiter

+

+ def _notify_waiter_done(self):

+ waiter = self._notify_waiter

+ if waiter is not None and not waiter.done():

+ waiter.set_result(True)

+

+ self._notify_waiter = None

+

+ # worker_int callback

+ self.cfg.worker_int(self)

+

+ # init closing process

+ self._closing = ensure_future(self.close(), loop=self.loop)

+

+ # close loop

+ self.loop.call_later(0.1, self._notify_waiter_done)

+

+ self.cfg.worker_abort(self)

+ sys.exit(1)

+class WSGIServer(Server):

+

+ def __init__(self, app, worker):

+ super().__init__(app, loop=worker.loop)

+

+ self.worker = worker

+ self.access_log_format = worker._get_valid_log_format(

+ worker.cfg.access_log_format)

+

+ def __call__(self):

+ return WSGIServerHttpProtocol(

+ self.handler, readpayload=True,

+ loop=self._loop,

+ logger=self.worker.log,

+ debug=self.worker.log.loglevel == logging.DEBUG,

+ keep_alive=self.worker.cfg.keepalive,

+ access_log=self.worker.log.access_log,

+ access_log_format=self.access_log_format)

+

+

+4a74b0a6d3f82f187d7c364e8662f23ceaba395e

+4a74b0a6d3f82f187d7c364e8662f23ceaba395e

+4a74b0a6d3f82f187d7c364e8662f23ceaba395e

+4a74b0a6d3f82f187d7c364e8662f23ceaba395e

+python-aiohttp_1.2.0.orig.tar.gz

+e84ce3866174b472a7647d07b8bed67db6f02716

+519187

+python-aiohttp (1.2.0-1) unstable; urgency=medium

+

+ * New upstream release

+ * debian/compat changed to 10 (this change also closes: 845178 thanks to

+ dh_autoreconf)

+

+ -- Piotr Ożarowski <piotr@debian.org> Wed, 21 Dec 2016 13:30:27 +0100

+

+10

+Build-Depends: debhelper (>= 10),

+.. _aiohttp_changes:

+

+Client

+======

+Client Reference

+================

+ .. deprecated:: 1.1

+

+based on `Ubuntu` 14.04.

+`Ubuntu` has a bug in pyenv, so to create virtualenv you need to do some

+Has aiohttp the Flask Blueprint or Django App concept?

+------------------------------------------------------

+

+If you're planing to write big applications, maybe you must consider

+use nested applications. They acts as a Flask Blueprint or like the

+Django application concept.

+

+Using nested application you can add sub-applications to the main application.

+

+see: :ref:`aiohttp-web-nested-applications`.

+

+

+This should not be an issue for most aiohttp users (for example `Ubuntu`

+ side_effect=lambda *args, **kwargs: AioESService(*args,

+ **kwargs,

+ loop=loop))):

+ side_effect=lambda *args, **kwargs: AioESService(*args,

+ **kwargs,

+ loop=loop))):

+

+API stability and deprecation policy

+------------------------------------

+

+aiohttp tries to not break existing users code.

+

+Obsolete attributes and methods are marked as *deprecated* in

+documentation and raises :class:`DeprecationWarning` on usage.

+

+Deprecation period is usually a year and half.

+

+After the period is passed out deprecated code is be removed.

+

+Unfortunately we should break own rules if new functionality or bug

+fixing forces us to do it (for example proper cookies support on

+client side forced us to break backward compatibility twice).

+

+All *backward incompatible* changes are explicitly marked in

+:ref:`CHANGES <aiohttp_changes>` chapter.

+

+

+How to enable gzip compression globally for the whole application?

+------------------------------------------------------------------

+

+It's impossible. Choosing what to compress and where don't apply such

+time consuming operation is very tricky matter.

+

+If you need global compression -- write own custom middleware. Or

+enable compression in NGINX (you are deploying aiohttp behind reverse

+proxy, isn't it).

+

+

+ web_lowlevel

+ server

+Deprecated Low-level Server

+===========================

+.. deprecated:: 1.2

+

+ The module has been deprecated and will be eventually removed. Use

+ :ref:`aiohttp-web-lowlevel` instead.

+

+ The new solution provides much more user friendly API.

+

+incapsulates

+unicode

+The Test Client and Servers

+~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+*aiohttp* test utils provides a scaffolding for testing aiohttp-based

+web servers.

+

+They are consist of two parts: running test server and making HTTP

+requests to this server.

+

+:class:`~aiohttp.test_utils.TestServer` runs :class:`aiohttp.web.Application`

+based server, :class:`~aiohttp.test_utils.RawTestServer` starts

+:class:`aiohttp.web.WebServer` low level server.

+

+For performing HTTP requests to these servers you have to create a

+test client: :class:`~aiohttp.test_utils.TestClient` instance.

+

+The client incapsulates :class:`aiohttp.ClientSession` by providing

+proxy methods to the client for common operations such as

+*ws_connect*, *get*, *post*, etc.

+

+

+

+Pytest

+~~~~~~

+Pytest tooling has the following fixtures:

+.. data:: test_server(app, **kwargs)

+ A fixture factory that creates

+ :class:`~aiohttp.test_utils.TestServer`::

+ async def test_f(loop, test_server):

+ app = web.Application(loop=loop)

+ # fill route table

+ server = await test_server(app)

+ The server will be destroyed on exit from test function.

+ *app* is the :class:`aiohttp.web.Application` used

+ to start server.

+ *kwargs* are parameters passed to

+ :meth:`aiohttp.web.Application.make_handler`

+.. data:: test_client(app, **kwargs)

+ test_client(server, **kwargs)

+ test_client(raw_server, **kwargs)

+ A fixture factory that creates

+ :class:`~aiohttp.test_utils.TestClient` for access to tested server::

+ async def test_f(loop, test_client):

+ app = web.Application(loop=loop)

+ # fill route table

+ client = await test_client(app)

+ resp = await client.get('/')

+ *client* and responses are cleaned up after test function finishing.

+ The fixture accepts :class:`aiohttp.web.Application`,

+ :class:`aiohttp.test_utils.TestServer` or

+ :class:`aiohttp.test_utils.RawTestServer` instance.

+

+ *kwargs* are parameters passed to

+ :class:`aiohttp.test_utils.TestClient` constructor.

+

+.. data:: raw_test_server(handler, **kwargs)

+ A fixture factory that creates

+ :class:`~aiohttp.test_utils.RawTestServer` instance from given web

+ handler.

+ *handler* should be a coroutine which accepts a request and returns

+ response, e.g.::

+ async def test_f(raw_test_server, test_client):

+ async def handler(request):

+ return web.Response(text="OK")

+

+ raw_server = await raw_test_server(handler)

+ client = await test_client(raw_server)

+ resp = await client.get('/')

+.. _aiohttp-testing-unittest-style:

+

+Unittest

+~~~~~~~~

+.. class:: AioHTTPTestCase

+

+ A base class to allow for unittest web applications using aiohttp.

+

+ Derived from :class:`unittest.TestCase`

+

+ Provides the following:

+

+ .. attribute:: client

+

+ an aiohttp test client, :class:`TestClient` instance.

+

+ .. attribute:: loop

+

+ The event loop in which the application and server are running.

+

+ .. attribute:: app

+

+ The application returned by :meth:`get_app`

+ (:class:`aiohttp.web.Application` instance).

+

+ .. method:: get_app(loop)

+

+ This method should be overridden

+ to return the :class:`aiohttp.web.Application`

+ object to test.

+

+ :param loop: the event_loop to use

+ :type loop: asyncio.AbstractEventLoop

+

+ :return: :class:`aiohttp.web.Application` instance.

+

+ .. method:: setUp()

+

+ Standard test initialization method.

+

+ .. method:: tearDown()

+

+ Standard test finalization method.

+

+

+ .. note::

+

+ The ``TestClient``'s methods are asynchronous: you have to

+ execute function on the test client using asynchronous methods.

+

+ A basic test class wraps every test method by

+ :func:`unittest_run_loop` decorator::

+

+ class TestA(AioHTTPTestCase):

+

+ @unittest_run_loop

+ async def test_f(self):

+ resp = await self.client.get('/')

+

+

+.. decorator:: unittest_run_loop:

+

+ A decorator dedicated to use with asynchronous methods of an

+ :class:`AioHTTPTestCase`.

+

+ Handles executing an asynchronous function, using

+ the :attr:`AioHTTPTestCase.loop` of the :class:`AioHTTPTestCase`.

+

+

+.. function:: make_mocked_request(method, path, headers=None, *, \

+ version=HttpVersion(1, 1), \

+ closing=False, \

+ app=None, \

+ reader=sentinel, \

+ writer=sentinel, \

+ transport=sentinel, \

+ payload=sentinel, \

+ sslcontext=None, \

+ secure_proxy_ssl_header=None)

+

+ Creates mocked web.Request testing purposes.

+

+ Useful in unit tests, when spinning full web server is overkill or

+ specific conditions and errors are hard to trigger.

+

+ :param method: str, that represents HTTP method, like; GET, POST.

+ :type method: str

+

+ :param path: str, The URL including *PATH INFO* without the host or scheme

+ :type path: str

+

+ :param headers: mapping containing the headers. Can be anything accepted

+ by the multidict.CIMultiDict constructor.

+ :type headers: dict, multidict.CIMultiDict, list of pairs

+

+ :param version: namedtuple with encoded HTTP version

+ :type version: aiohttp.protocol.HttpVersion

+

+ :param closing: flag indicates that connection should be closed after

+ response.

+ :type closing: bool

+

+ :param app: the aiohttp.web application attached for fake request

+ :type app: aiohttp.web.Application

+

+ :param reader: object for storing and managing incoming data

+ :type reader: aiohttp.parsers.StreamParser

+

+ :param writer: object for managing outcoming data

+ :type wirter: aiohttp.parsers.StreamWriter

+

+ :param transport: asyncio transport instance

+ :type transport: asyncio.transports.Transport

+

+ :param payload: raw payload reader object

+ :type payload: aiohttp.streams.FlowControlStreamReader

+

+ :param sslcontext: ssl.SSLContext object, for HTTPS connection

+ :type sslcontext: ssl.SSLContext

+

+ :param secure_proxy_ssl_header: A tuple representing a HTTP header/value

+ combination that signifies a request is secure.

+ :type secure_proxy_ssl_header: tuple

+

+ :return: :class:`aiohttp.web.Request` object.

+

+

+.. _aiohttp-testing-framework-agnostic-utilities:

+

+Framework Agnostic Utilities

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+High level test creation::

+

+ from aiohttp.test_utils import TestClient, loop_context

+ from aiohttp import request

+

+ # loop_context is provided as a utility. You can use any

+ # asyncio.BaseEventLoop class in it's place.

+ with loop_context() as loop:

+ app = _create_example_app(loop)

+ with TestClient(app) as client:

+

+ async def test_get_route():

+ nonlocal client

+ resp = await client.get("/")

+ assert resp.status == 200

+ text = await resp.text()

+ assert "Hello, world" in text

+

+ loop.run_until_complete(test_get_route())

+

+

+If it's preferred to handle the creation / teardown on a more granular

+basis, the TestClient object can be used directly::

+

+ from aiohttp.test_utils import TestClient

+

+ with loop_context() as loop:

+ app = _create_example_app(loop)

+ client = TestClient(app)

+ loop.run_until_complete(client.start_server())

+ root = "http://127.0.0.1:{}".format(port)

+

+ async def test_get_route():

+ resp = await client.get("/")

+ assert resp.status == 200

+ text = await resp.text()

+ assert "Hello, world" in text

+

+ loop.run_until_complete(test_get_route())

+ loop.run_until_complete(client.close())

+

+

+A full list of the utilities provided can be found at the

+:data:`api reference <aiohttp.test_utils>`

+

+.. class:: BaseTestServer(*, scheme='http', host='127.0.0.1')

+

+ Base class for test servers.

+

+ :param str scheme: HTTP scheme, non-protected ``"http"`` by default.

+

+ :param str host: a host for TCP socket, IPv4 *local host*

+ (``'127.0.0.1'``) by default.

+

+

+ .. attribute:: scheme

+

+ A *scheme* for tested application, ``'http'`` for non-protected

+ run and ``'htttps'`` for TLS encrypted server.

+

+ .. attribute:: host

+

+ *host* used to start a test server.

+

+ .. attribute:: port

+

+ A random *port* used to start a server.

+

+ .. attribute:: handler

+

+ :class:`aiohttp.web.WebServer` used for HTTP requests serving.

+

+ .. attribute:: server

+

+ :class:`asyncio.AbstractServer` used for managing accepted connections.

+

+ .. comethod:: start_server(**kwargs)

+

+ Start a test server.

+

+ .. comethod:: close()

+

+ Stop and finish executed test server.

+

+ .. method:: make_url(path)

+

+ Return an *absolute* :class:`~yarl.URL` for given *path*.

+

+

+.. class:: RawTestServer(handler, *, \

+ loop=None, scheme="http", host='127.0.0.1')

+

+ Low-level test server (derived from :class:`BaseTestServer`).

+

+ :param handler: a coroutine for handling web requests. The

+ handler should accept

+ :class:`aiohttp.web.BaseRequest` and return a

+ response instance,

+ e.g. :class:`~aiohttp.web.StreamResponse` or

+ :class:`~aiohttp.web.Response`.

+

+ The handler could raise

+ :class:`~aiohttp.web.HTTPException` as a signal for

+ non-200 HTTP response.

+

+ :param str scheme: HTTP scheme, non-protected ``"http"`` by default.

+

+ :param str host: a host for TCP socket, IPv4 *local host*

+ (``'127.0.0.1'``) by default.

+

+

+ Test server (derived from :class:`BaseTestServer`) for starting

+ :class:`~aiohttp.web.Application`.

+

+Test Client

+~~~~~~~~~~~

+

+.. class:: TestClient(app_or_server, *, \

+ scheme='http', host='127.0.0.1', \

+ cookie_jar=None, **kwargs)

+

+ A test client used for making calls to tested server.

+

+ :param app_or_server: :class:`BaseTestServer` instance for making

+ client requests to it.

+

+ If the parameter is

+ :class:`aiohttp.web.Application` the tool

+ creates :class:`TestServer` implicitly for

+ serving the application.

+

+ :param cookie_jar: an optional :class:`aiohttp.CookieJar` instance,

+ may be useful with ``CookieJar(unsafe=True)``

+ option.

+

+ :param str scheme: HTTP scheme, non-protected ``"http"`` by default.

+

+ :param str host: a host for TCP socket, IPv4 *local host*

+ (``'127.0.0.1'``) by default.

+

+ .. attribute:: server

+ :class:`BaseTestServer` test server instance used in conjunction

+ with client.

+ .. attribute:: session

+ An internal :class:`aiohttp.ClientSession`.

+

+ Unlike the methods on the :class:`TestClient`, client session

+ requests do not automatically include the host in the url

+ queried, and will require an absolute path to the resource.

+ Return an *absolute* :class:`~yarl.URL` for given *path*.

+ .. comethod:: request(method, path, *args, **kwargs)

+ Routes a request to tested http server.

+

+ The interface is identical to

+ :meth:`asyncio.ClientSession.request`, except the loop kwarg is

+ overridden by the instance used by the test server.

+

+ .. comethod:: get(path, *args, **kwargs)

+

+ Perform an HTTP GET request.

+

+ .. comethod:: post(path, *args, **kwargs)

+

+ Perform an HTTP POST request.

+

+ .. comethod:: options(path, *args, **kwargs)

+

+ Perform an HTTP OPTIONS request.

+

+ .. comethod:: head(path, *args, **kwargs)

+

+ Perform an HTTP HEAD request.

+

+ .. comethod:: put(path, *args, **kwargs)

+ Perform an HTTP PUT request.

+ .. comethod:: patch(path, *args, **kwargs)

+

+ Perform an HTTP PATCH request.

+

+ .. comethod:: delete(path, *args, **kwargs)

+

+ Perform an HTTP DELETE request.

+

+ .. comethod:: delete(path, *args, **kwargs)

+

+ Initiate websocket connection.

+

+ The api corresponds to :meth:`aiohttp.ClientSession.ws_connect`.

+

+

+Utilities

+~~~~~~~~~

+ :return int: ephemeral port number which could be reused by test server.

+

+.. function:: loop_context(loop_factory=<function asyncio.new_event_loop>)

+

+ A contextmanager that creates an event_loop, for test purposes.

+

+ Handles the creation and cleanup of a test loop.

+

+.. function:: setup_test_loop(loop_factory=<function asyncio.new_event_loop>)

+

+ Create and return an :class:`asyncio.AbstractEventLoop` instance.

+

+ The caller should also call teardown_test_loop, once they are done

+ with the loop.

+.. function:: teardown_test_loop(loop)

+ Teardown and cleanup an event_loop created by setup_test_loop.

+ :param loop: the loop to teardown

+ :type loop: asyncio.AbstractEventLoop

+- `aiocache <https://github.com/argaen/aiocache>`_ Caching for asyncio

+ with multiple backends (framework agnostic)

+Server Tutorial

+===============

+ 1.1.5

+ web.run_app(app, host='127.0.0.1', port=8080)

+Save it under ``aiohttpdemo_polls/main.py`` and start the server:

+

+.. code-block:: shell

+

+ $ python main.py

+

+You'll see the following output on the command line:

+

+.. code-block:: shell

+

+ ======== Running on http://127.0.0.1:8080 ========

+ (Press CTRL+C to quit)

+

+Open ``http://127.0.0.1:8080`` in browser or do

+

+.. code-block:: shell

+

+ $ curl -X GET localhost:8080

+

+Alas, for now both return only ``404: Not Found``.

+To show something more meaningful let's create a route and a view.

+

+.. _aiohttp-tutorial-views:

+

+Views

+-----

+

+Let's start from first views. Create the file ``aiohttpdemo_polls/views.py`` with the following::

+

+ from aiohttp import web

+

+

+ async def index(request):

+ return web.Response(text='Hello Aiohttp!')

+

+This is the simplest view possible in Aiohttp.

+Now we should create a route for this ``index`` view. Put this into ``aiohttpdemo_polls/routes.py`` (it is a good practice to separate views, routes, models etc. You'll have more of each, and it is nice to have them in different places)::

+

+ from views import index

+

+

+ def setup_routes(app):

+ app.router.add_get('/', index)

+

+

+Also, we should call ``setup_routes`` function somewhere, and the best place is in the ``main.py`` ::

+

+ import asyncio

+ from aiohttp import web

+ from routes import setup_routes

+

+

+ loop = asyncio.get_event_loop()

+ app = web.Application(loop=loop)

+ setup_routes(app)

+ web.run_app(app, host='127.0.0.1', port=8080)

+

+Start server again. Now if we open browser we can see:

+

+.. code-block:: shell

+

+ $ curl -X GET localhost:8080

+ Hello Aiohttp!

+

+Success! For now your working directory should look like this:

+

+.. code-block:: none

+

+ .

+ ├── ..

+ └── polls

+ ├── aiohttpdemo_polls

+ │ ├── main.py

+ │ ├── routes.py

+ │ └── views.py

+Server Usage

+============

+.. note::

+

+ Regex should match against *percent encoded* URL

+ (``request.rel_url_raw_path``). E.g. *space character* is encoded

+ as ``%20``.

+

+ According to

+ `RFC 3986 <https://tools.ietf.org/html/rfc3986.html#appendix-A>`_

+ allowed in path symbols are::

+

+ allowed = unreserved / pct-encoded / sub-delims

+ / ":" / "@" / "/"

+

+ pct-encoded = "%" HEXDIG HEXDIG

+

+ unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"

+

+ sub-delims = "!" / "$" / "&" / "'" / "(" / ")"

+ / "*" / "+" / "," / ";" / "="

+ >>> request.app.router['root'].url_for().with_query({"a": "b", "c": "d"})

+ # You cannot rely on Content-Length if transfer is chunked.

+Reading from the *WebSocket* (``await ws.receive()``) and closing it

+(``await ws.close()``) **must only** be done inside the request

+handler *task*; however, writing (``ws.send_str(...)``) to the

+*WebSocket* and canceling the handler task may be delegated to other

+tasks. See also :ref:`FAQ section

+<aiohttp_faq_terminating_websockets>`.

+.. _aiohttp-web-nested-applications:

+ :meth:`Server.shutdown` call with

+ loop.run_until_complete(handler.shutdown(60.0))

+.. _aiohttp-web-lowlevel:

+

+Low Level Server

+================

+

+.. currentmodule:: aiohttp.web

+

+

+This topic describes :mod:`aiohttp.web` based *low level* API.

+

+Abstract

+--------

+

+Sometimes user don't need high-level concepts introduced in

+:ref:`aiohttp-web`: applications, routers, middlewares and signals.

+

+All what is needed is supporting asynchronous callable which accepts a

+request and returns a response object.

+

+This is done by introducing :class:`aiohttp.web.WebServer` class which

+serves a *protocol factory* role for

+:meth:`asyncio.AbstractEventLoop.create_server` and bridges data

+stream to *web handler* and sends result back.

+

+

+Low level *web handler* should accept the single :class:`BaseRequest`

+parameter and performs one of the following actions:

+

+ 1. Return a :class:`Response` with the whole HTTP body stored in memory.

+

+ 2. Create a :class:`StreamResponse`, send headers by

+ :meth:`StreamResponse.prepare` call, send data chunks by

+ :meth:`StreamResponse.write` / :meth:`StreamResponse.drain`,

+ return finished response.

+

+ 3. Raise :class:`HTTPException` derived exception (see

+ :ref:`aiohttp-web-exceptions` section).

+

+ All other exceptions not derived from :class:`HTTPException`

+ leads to *500 Internal Server Error* response.

+

+ 4. Initiate and process Web-Socket connection by

+ :class:`WebSocketResponse` using (see :ref:`aiohttp-web-websockets`).

+

+

+Run a Basic Low-Level Server

+----------------------------

+

+The following code demonstrates very trivial usage example::

+

+ import asyncio

+ from aiohttp import web

+

+

+ async def handler(request):

+ return web.Response(text="OK")

+

+

+ async def main(loop):

+ server = web.Server(handler)

+ await loop.create_server(server, "127.0.0.1", 8080)

+ print("======= Serving on http://127.0.0.1:8080/ ======")

+

+ # pause here for very long time by serving HTTP requests and

+ # waiting for keyboard interruption

+ await asyncio.sleep(100*3600)

+

+

+ loop = asyncio.get_event_loop()

+

+ try:

+ loop.run_until_complete(main(loop))

+ except KeyboardInterrupt:

+ pass

+ loop.close()

+

+

+In the snippet we have ``handler`` which returns a regular

+:class:`Response` with ``"OK"`` in BODY.

+

+This *handler* is processed by ``server`` (:class:`Server` which acts

+as *protocol factory*). Network communication is created by

+``loop.create_server`` call to serve ``http://127.0.0.1:8080/``.

+

+The handler should process every request: ``GET``, ``POST``,

+Web-Socket for every *path*.

+

+The example is very basic: it always return ``200 OK`` response, real

+life code should be much more complex.

+

+

+.. disqus::

+ :title: aiohttp.web low-level server

+Server Reference

+================

+Request and Base Request

+------------------------

+:class:`BaseRequest` is used for :ref:`Low-Level

+Servers<aiohttp-web-lowlevel>` (which have no applications, routers, signals

+and middlewares) and :class:`Request` has an *application* and *match

+info* attributes.

+A :class:`BaseRequest`/:class:`Request` are :obj:`dict`-like objects,

+allowing them to be used for :ref:`sharing

+data<aiohttp-web-data-sharing>` among :ref:`aiohttp-web-middlewares`

+and :ref:`aiohttp-web-signals` handlers.

+.. class:: BaseRequest

+ .. attribute:: http_range

+

+ Read-only property that returns information about *Range* HTTP header.

+

+ Returns a :class:`slice` where ``.start`` is *left inclusive

+ bound*, ``.stop`` is *right exclusive bound* and ``.step`` is

+ ``1``.

+

+ The property might be used in two manners:

+

+ 1. Attribute-access style (example assumes that both left and

+ right borders are set, the real logic for case of open bounds

+ is more complex)::

+

+ rng = request.http_rangea

+ with open(filename, 'rb') as f:

+ f.seek(rng.start)

+ return f.read(rng.stop-rng.start)

+

+ 2. Slice-style::

+

+ return buffer[request.http_range]

+

+ .. versionadded:: 1.2

+

+.. class:: Request

+

+ An request used for receiving request's information by *web handler*.

+

+ Every :ref:`handler<aiohttp-web-handler>` accepts a request

+ instance as the first positional parameter.

+

+ The class in derived from :class:`BaseRequest`, shares all parent's

+ attributes and methods but has a couple of additional properties:

+

+ .. attribute:: match_info

+

+ Read-only property with :class:`~aiohttp.abc.AbstractMatchInfo`

+ instance for result of route resolving.

+

+ .. note::

+

+ Exact type of property depends on used router. If

+ ``app.router`` is :class:`UrlDispatcher` the property contains

+ :class:`UrlMappingMatchInfo` instance.

+

+ .. attribute:: app

+

+ An :class:`Application` instance used to call :ref:`request handler

+ <aiohttp-web-handler>`, Read-only property.

+

+ .. note::

+

+ You should never create the :class:`Request` instance manually

+ -- :mod:`aiohttp.web` does it for you. But

+ :meth:`~BaseRequest.clone` may be used for cloning *modified*

+ request copy with changed *path*, *method* etc.

+

+

+

+ .. attribute:: task

+

+ A task that serves HTTP request handling.

+

+ May be useful for graceful shutdown of long-running requests

+ (streaming, long polling or web-socket).

+

+ .. versionadded:: 1.2

+

+ :param bool autoping: Automatically send

+ :const:`~aiohttp.WSMsgType.PONG` on

+ :const:`~aiohttp.WSMsgType.PING`

+ message from client, and handle

+ :const:`~aiohttp.WSMsgType.PONG`

+ responses from client.

+ Note that server doesn't send

+ :const:`~aiohttp.WSMsgType.PING`

+ requests, you need to do this explicitly

+ using :meth:`ping` method.

+

+:class:`~aiohttp.web.Server` as a *protocol

+factory*. *Server* could be constructed with

+ :param float lingering_time: maximum time during which the server

+ reads and ignore additional data coming from the client when

+ lingering close is on. Use ``0`` for disabling lingering on

+ server channel closing.

+

+ :param float lingering_timeout: maximum waiting time for more

+ client data to arrive when lingering close is in effect

+

+Server

+^^^^^^

+

+A protocol factory compatible with

+:meth:`~asyncio.AbstreactEventLoop.create_server`.

+

+.. class:: Server

+

+ The class is responsible for creating HTTP protocol

+ objects that can handle HTTP connections.

+ .. attribute:: Server.connections

+ List of all currently opened connections.

+ .. attribute:: requests_count

+ Amount of processed requests.

+

+ .. versionadded:: 1.0

+ .. coroutinemethod:: Server.shutdown(timeout)

+ A :ref:`coroutine<coroutine>` that should be called to close all opened

+ connections.

+ .. coroutinemethod:: Server.finish_connections(timeout)

+ .. deprecated:: 1.2

+ A deprecated alias for :meth:`shutdown`.

+ .. versionchanged:: 1.2

+

+ ``Server`` was called ``RequestHandlerFactory`` before ``aiohttp==1.2``.

+

+ The rename has no deprecation period but it's safe: no user

+ should instantiate the class by hands.

+ If a gzip version of the static content exists at file path + ``.gz``, it

+ will be used for the response.

+

+ .. versionchanged:: 1.2.0

+ Send gzip version if file path + ``.gz`` exists.

+

+ await self.handler.shutdown()

+import asyncio

+from aiohttp import web

+

+

+async def handler(request):

+ return web.Response(text="OK")

+

+

+async def main(loop):

+ server = web.Server(handler)

+ await loop.create_server(server, "127.0.0.1", 8080)

+ print("======= Serving on http://127.0.0.1:8080/ ======")

+

+ # pause here for very long time by serving HTTP requests and

+ # waiting for keyboard interruption

+ await asyncio.sleep(100*3600)

+

+

+loop = asyncio.get_event_loop()

+

+try:

+ loop.run_until_complete(main(loop))

+except KeyboardInterrupt:

+ pass

+loop.close()

+from aiohttp.web import Application, HTTPException, Response, run_app

+ if not response.prepared:

+ return app

+app = init(loop)

+run_app(app)

+install_requires = ['chardet', 'multidict>=2.1.4',

+ 'async_timeout>=1.1.0', 'yarl>=0.8.1']

+ assert connector._release_acquired.called

+

+

+def test_detach_closed(connector, key, request, transport, protocol, loop):

+ conn = Connection(connector, key, request,

+ transport, protocol, loop)

+ conn.release()

+ conn.detach()

+

+ assert not connector._release_acquired.called

+ assert conn._transport is None

+ assert 'q=t est' in request.query_string

+def test_host_header_host_idna_encode(make_request):

+ req = make_request('get', 'http://xn--9caa.com')

+ assert req.headers['HOST'] == 'xn--9caa.com'

+

+

+def test_host_header_host_unicode(make_request):

+ req = make_request('get', 'http://éé.com')

+ assert req.headers['HOST'] == 'xn--9caa.com'

+

+

+ yield from asyncio.sleep(0.1, loop=loop)

+

+

+def test_create_session_outside_of_coroutine(loop):

+ with pytest.warns(ResourceWarning):

+ sess = ClientSession(loop=loop)

+ sess.close()

+def test_release_acquired(loop):

+ conn = aiohttp.BaseConnector(loop=loop, limit=5)

+ conn._release_waiter = unittest.mock.Mock()

+

+ key, tr = 1, unittest.mock.Mock()

+ conn._acquired[key].add(tr)

+ acquired = conn._release_acquired(key, tr)

+ assert 0 == len(conn._acquired[key])

+ assert acquired == conn._acquired[key]

+ assert not conn._release_waiter.called

+

+ acquired = conn._release_acquired(key, tr)

+ assert 0 == len(conn._acquired[key])

+ assert acquired is None

+

+ conn.close()

+

+

+def test_release_acquired_closed(loop):

+ conn = aiohttp.BaseConnector(loop=loop, limit=5)

+ conn._release_waiter = unittest.mock.Mock()

+

+ key, tr = 1, unittest.mock.Mock()

+ conn._acquired[key].add(tr)

+ conn._closed = True

+ conn._release_acquired(key, tr)

+ assert 1 == len(conn._acquired[key])

+ assert not conn._release_waiter.called

+ conn.close()

+

+

+ conn._release_waiter = unittest.mock.Mock()

+ assert conn._release_waiter.called

+def test_release_already_closed(loop):

+ conn = aiohttp.BaseConnector(loop=loop)

+

+ tr, proto = unittest.mock.Mock(), unittest.mock.Mock()

+ key = 1

+ conn._acquired[key].add(tr)

+ conn.close()

+

+ conn._start_cleanup_task = unittest.mock.Mock()

+ conn._release_waiter = unittest.mock.Mock()

+ conn._release_acquired = unittest.mock.Mock()

+ req = unittest.mock.Mock()

+

+ conn._release(key, req, tr, proto)

+ assert not conn._release_waiter.called

+ assert not conn._start_cleanup_task.called

+ assert not conn._release_acquired.called

+

+

+def test_release_do_not_call_release_waiter(loop):

+ req = unittest.mock.Mock()

+ resp = req.response = unittest.mock.Mock()

+ resp._should_close = False

+ tr, proto = unittest.mock.Mock(), unittest.mock.Mock()

+ key = 1

+

+ # limit is None

+ conn = aiohttp.BaseConnector(limit=None, loop=loop)

+ conn._release_waiter = unittest.mock.Mock()

+ conn._acquired[key].add(tr)

+ conn._release(key, req, tr, proto)

+ assert not conn._release_waiter.called

+ conn.close()

+

+ # acquired key error

+ conn = aiohttp.BaseConnector(loop=loop)

+ conn._release_waiter = unittest.mock.Mock()

+ conn._release(key, req, tr, proto)

+ assert not conn._release_waiter.called

+ conn.close()

+

+ # acquired len >= limit

+ conn = aiohttp.BaseConnector(limit=1, loop=loop)

+ conn._release_waiter = unittest.mock.Mock()

+ conn._acquired[key].add(unittest.mock.Mock())

+ conn._acquired[key].add(tr)

+ conn._release(key, req, tr, proto)

+ assert not conn._release_waiter.called

+ conn.close()

+

+

+def test_update_cookie_with_unicode_domain(loop):

+ cookies = (

+ "idna-domain-first=first; Domain=xn--9caa.com; Path=/;",

+ "idna-domain-second=second; Domain=xn--9caa.com; Path=/;",

+ )

+

+ jar = CookieJar(loop=loop)

+ jar.update_cookies(SimpleCookie(cookies[0]), URL("http://éé.com/"))

+ jar.update_cookies(SimpleCookie(cookies[1]), URL("http://xn--9caa.com/"))

+

+ jar_test = SimpleCookie()

+ for cookie in jar:

+ jar_test[cookie.key] = cookie

+

+ assert jar_test == SimpleCookie(" ".join(cookies))

+

+

+def test_filter_cookie_with_unicode_domain(loop):

+ jar = CookieJar(loop=loop)

+ jar.update_cookies(SimpleCookie(

+ "idna-domain-first=first; Domain=xn--9caa.com; Path=/; "

+ ))

+ assert len(jar.filter_cookies(URL("http://éé.com"))) == 1

+ assert len(jar.filter_cookies(URL("http://xn--9caa.com"))) == 1

+

+

+def test_preserving_quoted_cookies(loop):

+ jar = CookieJar(loop=loop, unsafe=True)

+ jar.update_cookies(SimpleCookie(

+ "ip-cookie=\"second\"; Domain=127.0.0.1;"

+ ))

+ cookies_sent = jar.filter_cookies(URL("http://127.0.0.1/")).output(

+ header='Cookie:')

+ assert cookies_sent == 'Cookie: ip-cookie=\"second\"'

+

+

+ # N.B. those need to be overridden in child test cases

+ def test_double_stopping(self, time_service):

+ time_service.stop()

+ time_service.stop()

+ assert time_service._cb is None

+ assert time_service._loop is None

+

+ def test_read_text_default_encoding(self):

+ obj = aiohttp.multipart.BodyPartReader(

+ self.boundary, {},

+ Stream('Привет, Мир!\r\n--:--'.encode('utf-8')))

+ result = yield from obj.text()

+ self.assertEqual('Привет, Мир!', result)

+

+ self.assertEqual(req.url, URL('http://www.python.org'))

+ @mock.patch('aiohttp.Request')

+ def test_connect_request_with_unicode_host(self, Request_mock):

+ loop = mock.Mock()

+ request = ClientRequest("CONNECT", URL("http://éé.com/"),

+ loop=loop)

+

+ request.response_class = mock.Mock()

+ request.write_bytes = mock.Mock()

+ request.write_bytes.return_value = asyncio.Future(loop=loop)

+ request.write_bytes.return_value.set_result(None)

+ request.send(mock.Mock(), mock.Mock())

+

+ Request_mock.assert_called_with(mock.ANY, mock.ANY, "xn--9caa.com:80",

+ mock.ANY)

+

+ self.assertEqual(req.url, URL('http://www.python.org'))

+ self.assertEqual(req.url, URL('http://www.python.org'))

+ self.assertEqual(proxy_req.url, URL('https://www.python.org'))

+ tr.close.assert_called_once_with()

+ self.assertEqual(req.url, URL('http://localhost:1234/path'))

+ self.assertEqual(proxy_req.url, URL('https://www.python.org'))

+ tr.close.assert_called_once_with()

+ self.assertEqual(req.url, URL('http://www.python.org'))

+import asyncio

+from functools import partial

+from unittest import mock

+

+import pytest

+from yarl import URL

+

+import aiohttp

+import aiohttp.helpers

+import aiohttp.web

+

+

+@pytest.fixture

+def proxy_test_server(raw_test_server, loop, monkeypatch):

+ """Handle all proxy requests and imitate remote server response."""

+

+ _patch_ssl_transport(monkeypatch)

+

+ default_response = dict(

+ status=200,

+ headers=None,

+ body=None)

+

+ @asyncio.coroutine

+ def proxy_handler(request, proxy_mock):

+ proxy_mock.request = request

+ proxy_mock.requests_list.append(request)

+

+ response = default_response.copy()

+ if isinstance(proxy_mock.return_value, dict):

+ response.update(proxy_mock.return_value)

+

+ if request.method == 'CONNECT':

+ response['body'] = None

+

+ return aiohttp.web.Response(**response)

+

+ @asyncio.coroutine

+ def proxy_server():

+ proxy_mock = mock.Mock()

+ proxy_mock.request = None

+ proxy_mock.requests_list = []

+

+ handler = partial(proxy_handler, proxy_mock=proxy_mock)

+ server = yield from raw_test_server(handler)

+

+ proxy_mock.server = server

+ proxy_mock.url = server.make_url('/')

+

+ return proxy_mock

+

+ return proxy_server

+

+

+@asyncio.coroutine

+def _request(method, url, loop=None, **kwargs):

+ with aiohttp.ClientSession(loop=loop) as client:

+ resp = yield from client.request(method, url, **kwargs)

+ yield from resp.release()

+ return resp

+

+

+@pytest.fixture()

+def get_request(loop):

+ return partial(_request, method='GET', loop=loop)

+

+

+@asyncio.coroutine

+def test_proxy_http_absolute_path(proxy_test_server, get_request):

+ url = 'http://aiohttp.io/path?query=yes'

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ assert len(proxy.requests_list) == 1

+ assert proxy.request.method == 'GET'

+ assert proxy.request.host == 'aiohttp.io'

+ assert proxy.request.path_qs == 'http://aiohttp.io/path?query=yes'

+

+

+@asyncio.coroutine

+def test_proxy_http_raw_path(proxy_test_server, get_request):

+ url = 'http://aiohttp.io:2561/space sheep?q=can:fly'

+ raw_url = 'http://aiohttp.io:2561/space%20sheep?q=can:fly'

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ assert proxy.request.host == 'aiohttp.io:2561'

+ assert proxy.request.path_qs == raw_url

+

+

+@asyncio.coroutine

+def test_proxy_http_idna_support(proxy_test_server, get_request):

+ url = 'http://éé.com/'

+ raw_url = 'http://xn--9caa.com/'

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ assert proxy.request.host == 'xn--9caa.com'

+ assert proxy.request.path_qs == raw_url

+

+

+@asyncio.coroutine

+def test_proxy_http_connection_error(get_request):

+ url = 'http://aiohttp.io/path'

+ proxy_url = 'http://localhost:2242/'

+

+ with pytest.raises(aiohttp.ProxyConnectionError):

+ yield from get_request(url=url, proxy=proxy_url)

+

+

+@asyncio.coroutine

+def test_proxy_http_bad_response(proxy_test_server, get_request):

+ url = 'http://aiohttp.io/path'

+ proxy = yield from proxy_test_server()

+ proxy.return_value = dict(

+ status=502,

+ headers={'Proxy-Agent': 'TestProxy'})

+

+ resp = yield from get_request(url=url, proxy=proxy.url)

+

+ assert resp.status == 502

+ assert resp.headers['Proxy-Agent'] == 'TestProxy'

+

+

+@asyncio.coroutine

+def test_proxy_http_auth(proxy_test_server, get_request):

+ url = 'http://aiohttp.io/path'

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ assert 'Authorization' not in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ auth = aiohttp.helpers.BasicAuth('user', 'pass')

+ yield from get_request(url=url, auth=auth, proxy=proxy.url)

+

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ yield from get_request(url=url, proxy_auth=auth, proxy=proxy.url)

+

+ assert 'Authorization' not in proxy.request.headers

+ assert 'Proxy-Authorization' in proxy.request.headers

+

+ yield from get_request(url=url, auth=auth,

+ proxy_auth=auth, proxy=proxy.url)

+

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' in proxy.request.headers

+

+

+@asyncio.coroutine

+def test_proxy_http_auth_utf8(proxy_test_server, get_request):

+ url = 'http://aiohttp.io/path'

+ auth = aiohttp.helpers.BasicAuth('юзер', 'пасс', 'utf-8')

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, auth=auth, proxy=proxy.url)

+

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+

+@asyncio.coroutine

+def test_proxy_http_auth_from_url(proxy_test_server, get_request):

+ url = 'http://aiohttp.io/path'

+ proxy = yield from proxy_test_server()

+

+ auth_url = URL(url).with_user('user').with_password('pass')

+ yield from get_request(url=auth_url, proxy=proxy.url)

+

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ proxy_url = URL(proxy.url).with_user('user').with_password('pass')

+ yield from get_request(url=url, proxy=proxy_url)

+

+ assert 'Authorization' not in proxy.request.headers

+ assert 'Proxy-Authorization' in proxy.request.headers

+

+

+@asyncio.coroutine

+def test_proxy_http_acquired_cleanup(proxy_test_server, loop):

+ url = 'http://aiohttp.io/path'

+ key = ('aiohttp.io', 80, False)

+

+ conn = aiohttp.TCPConnector(loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ assert 0 == len(conn._acquired.keys())

+

+ @asyncio.coroutine

+ def request():

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ assert 1 == len(conn._acquired.keys())

+ assert 1 == len(conn._acquired[key])

+

+ yield from resp.release()

+

+ yield from request()

+

+ assert 0 == len(conn._acquired[key])

+

+ yield from sess.close()

+

+

+@asyncio.coroutine

+def test_proxy_http_acquired_cleanup_force(proxy_test_server, loop):

+ url = 'http://aiohttp.io/path'

+ key = ('aiohttp.io', 80, False)

+

+ conn = aiohttp.TCPConnector(force_close=True, loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ assert 0 == len(conn._acquired.keys())

+

+ @asyncio.coroutine

+ def request():

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ assert 1 == len(conn._acquired.keys())

+ assert 1 == len(conn._acquired[key])

+

+ yield from resp.release()

+

+ yield from request()

+

+ assert 0 == len(conn._acquired[key])

+

+ yield from sess.close()

+

+

+@asyncio.coroutine

+def test_proxy_http_multi_conn_limit(proxy_test_server, loop):

+ url = 'http://aiohttp.io/path'

+ limit, multi_conn_num = 1, 5

+

+ conn = aiohttp.TCPConnector(limit=limit, loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ current_pid = None

+

+ @asyncio.coroutine

+ def request(pid):

+ # process requests only one by one

+ nonlocal current_pid

+

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ current_pid = pid

+ yield from asyncio.sleep(0.2, loop=loop)

+ assert current_pid == pid

+

+ yield from resp.release()

+ return resp

+

+ requests = [request(pid) for pid in range(multi_conn_num)]

+ responses = yield from asyncio.gather(*requests, loop=loop)

+

+ assert len(responses) == multi_conn_num

+ assert set(resp.status for resp in responses) == {200}

+

+ yield from sess.close()

+

+

+@asyncio.coroutine

+def test_proxy_https_connect(proxy_test_server, get_request):

+ proxy = yield from proxy_test_server()

+ url = 'https://www.google.com.ua/search?q=aiohttp proxy'

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert connect.method == 'CONNECT'

+ assert connect.path == 'www.google.com.ua:443'

+ assert connect.host == 'www.google.com.ua'

+

+ assert proxy.request.host == 'www.google.com.ua'

+ assert proxy.request.path_qs == '/search?q=aiohttp+proxy'

+

+

+@asyncio.coroutine

+def test_proxy_https_connect_with_port(proxy_test_server, get_request):

+ proxy = yield from proxy_test_server()

+ url = 'https://secure.aiohttp.io:2242/path'

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert connect.method == 'CONNECT'

+ assert connect.path == 'secure.aiohttp.io:2242'

+ assert connect.host == 'secure.aiohttp.io:2242'

+

+ assert proxy.request.host == 'secure.aiohttp.io:2242'

+ assert proxy.request.path_qs == '/path'

+

+

+@asyncio.coroutine

+def test_proxy_https_send_body(proxy_test_server, loop):

+ sess = aiohttp.ClientSession(loop=loop)

+ proxy = yield from proxy_test_server()

+ proxy.return_value = {'status': 200, 'body': b'1'*(2**20)}

+ url = 'https://www.google.com.ua/search?q=aiohttp proxy'

+

+ resp = yield from sess.get(url, proxy=proxy.url)

+ body = yield from resp.read()

+ yield from resp.release()

+ yield from sess.close()

+

+ assert body == b'1'*(2**20)

+

+

+@asyncio.coroutine

+def test_proxy_https_idna_support(proxy_test_server, get_request):

+ url = 'https://éé.com/'

+ proxy = yield from proxy_test_server()

+

+ yield from get_request(url=url, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert connect.method == 'CONNECT'

+ assert connect.path == 'xn--9caa.com:443'

+ assert connect.host == 'xn--9caa.com'

+

+

+@asyncio.coroutine

+def test_proxy_https_connection_error(get_request):

+ url = 'https://secure.aiohttp.io/path'

+ proxy_url = 'http://localhost:2242/'

+

+ with pytest.raises(aiohttp.ProxyConnectionError):

+ yield from get_request(url=url, proxy=proxy_url)

+

+

+@asyncio.coroutine

+def test_proxy_https_bad_response(proxy_test_server, get_request):

+ url = 'https://secure.aiohttp.io/path'

+ proxy = yield from proxy_test_server()

+ proxy.return_value = dict(

+ status=502,

+ headers={'Proxy-Agent': 'TestProxy'})

+

+ with pytest.raises(aiohttp.HttpProxyError):

+ yield from get_request(url=url, proxy=proxy.url)

+

+ assert len(proxy.requests_list) == 1

+ assert proxy.request.method == 'CONNECT'

+ assert proxy.request.path == 'secure.aiohttp.io:443'

+

+

+@asyncio.coroutine

+def test_proxy_https_auth(proxy_test_server, get_request):

+ url = 'https://secure.aiohttp.io/path'

+ auth = aiohttp.helpers.BasicAuth('user', 'pass')

+

+ proxy = yield from proxy_test_server()

+ yield from get_request(url=url, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert 'Authorization' not in connect.headers

+ assert 'Proxy-Authorization' not in connect.headers

+ assert 'Authorization' not in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ proxy = yield from proxy_test_server()

+ yield from get_request(url=url, auth=auth, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert 'Authorization' not in connect.headers

+ assert 'Proxy-Authorization' not in connect.headers

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ proxy = yield from proxy_test_server()

+ yield from get_request(url=url, proxy_auth=auth, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert 'Authorization' not in connect.headers

+ assert 'Proxy-Authorization' in connect.headers

+ assert 'Authorization' not in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+ proxy = yield from proxy_test_server()

+ yield from get_request(url=url, auth=auth,

+ proxy_auth=auth, proxy=proxy.url)

+

+ connect = proxy.requests_list[0]

+ assert 'Authorization' not in connect.headers

+ assert 'Proxy-Authorization' in connect.headers

+ assert 'Authorization' in proxy.request.headers

+ assert 'Proxy-Authorization' not in proxy.request.headers

+

+

+@asyncio.coroutine

+def test_proxy_https_acquired_cleanup(proxy_test_server, loop):

+ url = 'https://secure.aiohttp.io/path'

+ key = ('secure.aiohttp.io', 443, True)

+

+ conn = aiohttp.TCPConnector(loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ assert 0 == len(conn._acquired.keys())

+

+ @asyncio.coroutine

+ def request():

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ assert 1 == len(conn._acquired.keys())

+ assert 1 == len(conn._acquired[key])

+

+ yield from resp.release()

+

+ yield from request()

+

+ assert 0 == len(conn._acquired[key])

+

+ yield from sess.close()

+

+

+@asyncio.coroutine

+def test_proxy_https_acquired_cleanup_force(proxy_test_server, loop):

+ url = 'https://secure.aiohttp.io/path'

+ key = ('secure.aiohttp.io', 443, True)

+

+ conn = aiohttp.TCPConnector(force_close=True, loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ assert 0 == len(conn._acquired.keys())

+

+ @asyncio.coroutine

+ def request():

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ assert 1 == len(conn._acquired.keys())

+ assert 1 == len(conn._acquired[key])

+

+ yield from resp.release()

+

+ yield from request()

+

+ assert 0 == len(conn._acquired[key])

+

+ yield from sess.close()

+

+

+@asyncio.coroutine

+def test_proxy_https_multi_conn_limit(proxy_test_server, loop):

+ url = 'https://secure.aiohttp.io/path'

+ limit, multi_conn_num = 1, 5

+

+ conn = aiohttp.TCPConnector(limit=limit, loop=loop)

+ sess = aiohttp.ClientSession(connector=conn, loop=loop)

+ proxy = yield from proxy_test_server()

+

+ current_pid = None

+

+ @asyncio.coroutine

+ def request(pid):

+ # process requests only one by one

+ nonlocal current_pid

+

+ resp = yield from sess.get(url, proxy=proxy.url)

+

+ current_pid = pid

+ yield from asyncio.sleep(0.2, loop=loop)

+ assert current_pid == pid

+

+ yield from resp.release()

+ return resp

+

+ requests = [request(pid) for pid in range(multi_conn_num)]

+ responses = yield from asyncio.gather(*requests, loop=loop)

+

+ assert len(responses) == multi_conn_num

+ assert set(resp.status for resp in responses) == {200}

+

+ yield from sess.close()

+

+

+def _patch_ssl_transport(monkeypatch):

+ """Make ssl transport substitution to prevent ssl handshake."""

+ def _make_ssl_transport_dummy(self, rawsock, protocol, sslcontext,

+ waiter=None, **kwargs):

+ return self._make_socket_transport(rawsock, protocol, waiter,

+ extra=kwargs.get('extra'),

+ server=kwargs.get('server'))

+

+ monkeypatch.setattr(

+ "asyncio.selector_events.BaseSelectorEventLoop._make_ssl_transport",

+ _make_ssl_transport_dummy)

+ assert cli.server.app['value'] == 'foo'

+ cli.server.app['value'] = 'bar'

+ srv.data_received(b''.join([b'a' for _ in range(10000)]) + b'\r\n\r\n')

+def test_handle_uncompleted(make_srv, loop):

+ closed = False

+

+ def close():

+ nonlocal closed

+ closed = True

+

+ transport.close = close

+

+ srv = make_srv(lingering_timeout=0)

+

+ assert closed

+@asyncio.coroutine

+def test_lingering(srv, loop):

+

+ transport = mock.Mock()

+ srv.connection_made(transport)

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+

+ srv.reader.feed_data(

+ b'GET / HTTP/1.0\r\n'

+ b'Host: example.com\r\n'

+ b'Content-Length: 0\r\n\r\n')

+

+ srv.reader.feed_data(b'123')

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+ srv.reader.feed_eof()

+

+ yield from asyncio.sleep(0, loop=loop)

+ transport.close.assert_called_with()

+

+

+@asyncio.coroutine

+def test_lingering_disabled(make_srv, loop):

+ srv = make_srv(lingering_time=0)

+

+ transport = mock.Mock()

+ srv.connection_made(transport)

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+

+ srv.reader.feed_data(

+ b'GET / HTTP/1.0\r\n'

+ b'Host: example.com\r\n'

+ b'Content-Length: 50\r\n\r\n')

+

+ srv.reader.feed_data(b'123')

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+ srv.reader.feed_eof()

+

+ yield from asyncio.sleep(0, loop=loop)

+ transport.close.assert_called_with()

+

+

+@asyncio.coroutine

+def test_lingering_zero_timeout(make_srv, loop):

+ srv = make_srv(lingering_time=1e-30)

+

+ transport = mock.Mock()

+ srv.connection_made(transport)

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+

+ srv.reader.feed_data(

+ b'GET / HTTP/1.0\r\n'

+ b'Host: example.com\r\n'

+ b'Content-Length: 50\r\n\r\n')

+

+ srv.reader.feed_data(b'123')

+

+ yield from asyncio.sleep(0, loop=loop)

+ assert not transport.close.called

+ srv.reader.feed_eof()

+

+ yield from asyncio.sleep(0, loop=loop)

+ transport.close.assert_called_with()

+

+

+from aiohttp.test_utils import (AioHTTPTestCase, RawTestServer, loop_context,

+

+

+def test_raw_server_implicit_loop(loop):

+ @asyncio.coroutine

+ def handler(request):

+ pass

+ asyncio.set_event_loop(loop)

+ srv = RawTestServer(handler)

+ assert srv._loop is loop

+ SystemRoute, UrlDispatcher, View,

+

+

+def test_add_to_non_initialized_router():

+ router = UrlDispatcher()

+ with pytest.raises(RuntimeError):

+ router.add_get('/', make_handler())

+ srv = mocker.patch('aiohttp.web.Server')

+ assert srv.call_count == 2

+ srv.assert_called_with(app._handle,

+ request_factory=app._make_request,

+ loop=loop,

+ debug=debug)

+

+

+def test_secure_proxy_ssl_header_default(loop):

+ app = web.Application(loop=loop)

+ assert app._secure_proxy_ssl_header is None

+

+

+@asyncio.coroutine

+def test_secure_proxy_ssl_header_non_default(loop):

+ app = web.Application(loop=loop)

+ hdr = ('X-Forwarded-Proto', 'https')

+ app.make_handler(secure_proxy_ssl_header=hdr)

+ assert app._secure_proxy_ssl_header is hdr

+ assert logger.exception.called

+ assert client.server.handler.requests_count == 0

+ assert client.server.handler.requests_count == 1

+ assert client.server.handler.requests_count == 2

+ assert client.server.handler.requests_count == 3

+

+

+@asyncio.coroutine

+def test_response_task(loop, test_client):

+

+ srv_resp = None

+

+ @asyncio.coroutine

+ def handler(request):

+ nonlocal srv_resp

+ srv_resp = web.StreamResponse()

+ assert srv_resp.task is None

+ yield from srv_resp.prepare(request)

+ assert srv_resp.task is not None

+ return srv_resp

+

+ app = web.Application(loop=loop)

+ app.router.add_get('/', handler)

+ client = yield from test_client(app)

+

+ resp = yield from client.get('/')

+ assert 200 == resp.status

+ assert srv_resp.task is None

+@asyncio.coroutine

+def test_changing_status_after_prepare_raises():

+ resp = StreamResponse()

+ yield from resp.prepare(make_request('GET', '/'))

+ with pytest.raises(RuntimeError):

+ resp.set_status(400)

+

+

+def test_response_with_content_length_header_without_body():

+ resp = Response(headers={'Content-Length': 123})

+ assert resp.content_length == 123

+

+

+from yarl import URL

+

+from aiohttp import hdrs, helpers

+from aiohttp.test_utils import make_mocked_coro, make_mocked_request

+

+

+def test_using_gzip_if_header_present_and_file_available(loop):

+ request = make_mocked_request(

+ 'GET', URL('http://python.org/logo.png'), headers={

+ hdrs.ACCEPT_ENCODING: 'gzip'

+ }

+ )

+

+ gz_filepath = mock.Mock()

+ gz_filepath.open = mock.mock_open()

+ gz_filepath.is_file.return_value = True

+ gz_filepath.stat.return_value = mock.MagicMock()

+ gz_filepath.stat.st_size = 1024

+

+ filepath = mock.Mock()

+ filepath.name = 'logo.png'

+ filepath.open = mock.mock_open()

+ filepath.with_name.return_value = gz_filepath

+

+ file_sender = FileSender()

+ file_sender._sendfile = make_mocked_coro(None)

+

+ loop.run_until_complete(file_sender.send(request, filepath))

+

+ assert not filepath.open.called

+ assert gz_filepath.open.called

+

+

+def test_gzip_if_header_not_present_and_file_available(loop):

+ request = make_mocked_request(

+ 'GET', URL('http://python.org/logo.png'), headers={

+ }

+ )

+

+ gz_filepath = mock.Mock()

+ gz_filepath.open = mock.mock_open()

+ gz_filepath.is_file.return_value = True

+

+ filepath = mock.Mock()

+ filepath.name = 'logo.png'

+ filepath.open = mock.mock_open()

+ filepath.with_name.return_value = gz_filepath

+ filepath.stat.return_value = mock.MagicMock()

+ filepath.stat.st_size = 1024

+

+ file_sender = FileSender()

+ file_sender._sendfile = make_mocked_coro(None)

+

+ loop.run_until_complete(file_sender.send(request, filepath))

+

+ assert filepath.open.called

+ assert not gz_filepath.open.called

+

+

+def test_gzip_if_header_not_present_and_file_not_available(loop):

+ request = make_mocked_request(

+ 'GET', URL('http://python.org/logo.png'), headers={

+ }

+ )

+

+ gz_filepath = mock.Mock()

+ gz_filepath.open = mock.mock_open()

+ gz_filepath.is_file.return_value = False

+

+ filepath = mock.Mock()

+ filepath.name = 'logo.png'

+ filepath.open = mock.mock_open()

+ filepath.with_name.return_value = gz_filepath

+ filepath.stat.return_value = mock.MagicMock()

+ filepath.stat.st_size = 1024

+

+ file_sender = FileSender()

+ file_sender._sendfile = make_mocked_coro(None)

+

+ loop.run_until_complete(file_sender.send(request, filepath))

+

+ assert filepath.open.called

+ assert not gz_filepath.open.called

+

+

+def test_gzip_if_header_present_and_file_not_available(loop):

+ request = make_mocked_request(

+ 'GET', URL('http://python.org/logo.png'), headers={

+ hdrs.ACCEPT_ENCODING: 'gzip'

+ }

+ )

+

+ gz_filepath = mock.Mock()

+ gz_filepath.open = mock.mock_open()

+ gz_filepath.is_file.return_value = False

+

+ filepath = mock.Mock()

+ filepath.name = 'logo.png'

+ filepath.open = mock.mock_open()

+ filepath.with_name.return_value = gz_filepath

+ filepath.stat.return_value = mock.MagicMock()

+ filepath.stat.st_size = 1024

+

+ file_sender = FileSender()

+ file_sender._sendfile = make_mocked_coro(None)

+

+ loop.run_until_complete(file_sender.send(request, filepath))

+

+ assert filepath.open.called

+ assert not gz_filepath.open.called

+

+

+@asyncio.coroutine

+def test_static_file_range(loop, test_client, sender):

+ filepath = (pathlib.Path(__file__).parent /

+ 'software_development_in_picture.jpg')

+

+ @asyncio.coroutine

+ def handler(request):

+ resp = yield from sender(chunk_size=16).send(request, filepath)

+ return resp

+

+ app = web.Application(loop=loop)

+ app.router.add_get('/', handler)

+ client = yield from test_client(lambda loop: app)

+

+ with filepath.open('rb') as f:

+ content = f.read()

+

+ # Ensure the whole file requested in parts is correct

+ responses = yield from asyncio.gather(

+ client.get('/', headers={'Range': 'bytes=0-999'}),

+ client.get('/', headers={'Range': 'bytes=1000-1999'}),

+ client.get('/', headers={'Range': 'bytes=2000-'}),

+ loop=loop

+ )

+ assert len(responses) == 3

+ assert responses[0].status == 206, \

+ "failed 'bytes=0-999': %s" % responses[0].reason

+ assert responses[1].status == 206, \

+ "failed 'bytes=1000-1999': %s" % responses[1].reason

+ assert responses[2].status == 206, \

+ "failed 'bytes=2000-': %s" % responses[2].reason

+

+ body = yield from asyncio.gather(

+ *(resp.read() for resp in responses),

+ loop=loop

+ )

+

+ assert len(body[0]) == 1000, \

+ "failed 'bytes=0-999', received %d bytes" % len(body[0])

+ assert len(body[1]) == 1000, \

+ "failed 'bytes=1000-1999', received %d bytes" % len(body[1])

+ responses[0].close()

+ responses[1].close()

+ responses[2].close()

+

+ assert content == b"".join(body)

+

+

+@asyncio.coroutine

+def test_static_file_range_tail(loop, test_client, sender):

+ filepath = (pathlib.Path(__file__).parent /

+ 'software_development_in_picture.jpg')

+

+ @asyncio.coroutine

+ def handler(request):

+ resp = yield from sender(chunk_size=16).send(request, filepath)

+ return resp

+

+ app = web.Application(loop=loop)

+ app.router.add_get('/', handler)

+ client = yield from test_client(lambda loop: app)

+

+ with filepath.open('rb') as f:

+ content = f.read()

+

+ # Ensure the tail of the file is correct

+ resp = yield from client.get('/', headers={'Range': 'bytes=-500'})

+ assert resp.status == 206, resp.reason

+ body4 = yield from resp.read()

+ resp.close()

+ assert content[-500:] == body4

+

+

+@asyncio.coroutine

+def test_static_file_invalid_range(loop, test_client, sender):

+ filepath = (pathlib.Path(__file__).parent /

+ 'software_development_in_picture.jpg')

+

+ @asyncio.coroutine

+ def handler(request):

+ resp = yield from sender(chunk_size=16).send(request, filepath)

+ return resp

+

+ app = web.Application(loop=loop)

+ app.router.add_get('/', handler)

+ client = yield from test_client(lambda loop: app)

+

+ flen = filepath.stat().st_size

+

+ # range must be in bytes

+ resp = yield from client.get('/', headers={'Range': 'blocks=0-10'})

+ assert resp.status == 416, 'Range must be in bytes'

+ resp.close()

+

+ # Range end is inclusive

+ resp = yield from client.get('/', headers={'Range': 'bytes=0-%d' % flen})

+ assert resp.status == 416, 'Range end must be inclusive'

+ resp.close()

+

+ # start > end

+ resp = yield from client.get('/', headers={'Range': 'bytes=100-0'})

+ assert resp.status == 416, "Range start can't be greater than end"

+ resp.close()

+

+ # start > end

+ resp = yield from client.get('/', headers={'Range': 'bytes=10-9'})

+ assert resp.status == 416, "Range start can't be greater than end"

+ resp.close()

+

+ # non-number range

+ resp = yield from client.get('/', headers={'Range': 'bytes=a-f'})

+ assert resp.status == 416, 'Range must be integers'

+ resp.close()

+

+ # double dash range

+ resp = yield from client.get('/', headers={'Range': 'bytes=0--10'})

+ assert resp.status == 416, 'double dash in range'

+ resp.close()

+

+ # no range

+ resp = yield from client.get('/', headers={'Range': 'bytes=-'})

+ assert resp.status == 416, 'no range given'

+ resp.close()

+import asyncio

+from unittest import mock

+

+from aiohttp import web

+

+

+@asyncio.coroutine

+def test_simple_server(raw_test_server, test_client):

+ @asyncio.coroutine

+ def handler(request):

+ return web.Response(text=str(request.rel_url))

+

+ server = yield from raw_test_server(handler)

+ client = yield from test_client(server)

+ resp = yield from client.get('/path/to')

+ assert resp.status == 200

+ txt = yield from resp.text()

+ assert txt == '/path/to'

+

+

+@asyncio.coroutine

+def test_raw_server_not_http_exception(raw_test_server, test_client):

+ exc = RuntimeError("custom runtime error")

+

+ @asyncio.coroutine

+ def handler(request):

+ raise exc

+

+ logger = mock.Mock()

+ server = yield from raw_test_server(handler, logger=logger)

+ client = yield from test_client(server)

+ resp = yield from client.get('/path/to')

+ assert resp.status == 500

+

+ txt = yield from resp.text()

+ assert "<h1>500 Internal Server Error</h1>" in txt

+

+ logger.exception.assert_called_with(

+ "Error handling request",

+ exc_info=exc)

+

+

+@asyncio.coroutine

+def test_raw_server_not_http_exception_debug(raw_test_server, test_client):

+ exc = RuntimeError("custom runtime error")

+

+ @asyncio.coroutine

+ def handler(request):

+ raise exc

+

+ logger = mock.Mock()

+ server = yield from raw_test_server(handler, logger=logger, debug=True)

+ client = yield from test_client(server)

+ resp = yield from client.get('/path/to')

+ assert resp.status == 500

+

+ txt = yield from resp.text()

+ assert "<h2>Traceback:</h2>" in txt

+

+ logger.exception.assert_called_with(

+ "Error handling request",

+ exc_info=exc)

+

+

+def test_create_web_server_with_implicit_loop(loop):

+ asyncio.set_event_loop(loop)

+

+ @asyncio.coroutine

+ def handler(request):

+ return web.Response() # pragma: no cover

+

+ srv = web.Server(handler)

+ assert srv._loop is loop

+from aiohttp import abc, web

+

+

+@asyncio.coroutine

+def test_412_is_returned(loop, test_client):

+

+ class MyRouter(abc.AbstractRouter):

+

+ @asyncio.coroutine

+ def resolve(self, request):

+ raise web.HTTPPreconditionFailed()

+

+ app = web.Application(router=MyRouter(), loop=loop)

+

+ client = yield from test_client(app)

+

+ resp = yield from client.get('/')

+

+ assert resp.status == 412

+def test_run_wsgi(worker, loop):

+ worker.wsgi = lambda env, start_resp: start_resp()

+

+ worker.loop = loop

+ worker._run = mock.Mock(

+ wraps=asyncio.coroutine(lambda: None))

+ with pytest.raises(SystemExit):

+ worker.run()

+ assert worker._run.called

+ assert loop.is_closed()

+

+

+ with mock.patch('aiohttp.worker.ensure_future') as m_ensure_future:

+ worker.loop = mock.Mock()

+ worker.handle_quit(object(), object())

+ assert not worker.alive

+ assert worker.exit_code == 0

+ assert m_ensure_future.called

+ worker.loop.call_later.asset_called_with(

+ 0.1, worker._notify_waiter_done)

+ with mock.patch('aiohttp.worker.sys') as m_sys:

+ worker.handle_abort(object(), object())

+ assert not worker.alive

+ assert worker.exit_code == 1

+ m_sys.exit.assert_called_with(1)

+

+

+def test__wait_next_notify(worker):

+ worker.loop = mock.Mock()

+ worker._notify_waiter_done = mock.Mock()

+ fut = worker._wait_next_notify()

+

+ assert worker._notify_waiter == fut

+ worker.loop.call_later.assert_called_with(1.0, worker._notify_waiter_done)

+

+

+def test__notify_waiter_done(worker):

+ worker._notify_waiter = None

+ worker._notify_waiter_done()

+ assert worker._notify_waiter is None

+

+ waiter = worker._notify_waiter = mock.Mock()

+ worker._notify_waiter.done.return_value = False

+ worker._notify_waiter_done()

+

+ assert worker._notify_waiter is None

+ waiter.set_result.assert_called_with(True)

+def test_make_handler_wsgi(worker, mocker):

+ worker.wsgi = lambda env, start_resp: start_resp()

+ worker.loop = mock.Mock()

+ worker.log = mock.Mock()

+ worker.cfg = mock.Mock()

+ worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT

+ mocker.spy(worker, '_get_valid_log_format')

+

+ f = worker.make_handler(worker.wsgi)

+ assert isinstance(f, base_worker.WSGIServer)

+ assert isinstance(f(), base_worker.WSGIServerHttpProtocol)

+ assert worker._get_valid_log_format.called

+

+

+ worker._wait_next_notify = mock.Mock()

+ assert worker._wait_next_notify.called

+ handler.shutdown.return_value = helpers.create_future(loop)

+ handler.shutdown.return_value.set_result(1)

+ handler.shutdown.assert_called_with(timeout=95.0)

+ srv.close.assert_called_with()

+ assert worker.servers is None

+

+ yield from worker.close()

+

+

+@asyncio.coroutine

+def test_close_wsgi(worker, loop):

+ srv = mock.Mock()

+ srv.wait_closed = make_mocked_coro(None)

+ handler = mock.Mock()

+ worker.servers = {srv: handler}

+ worker.log = mock.Mock()

+ worker.loop = loop

+ worker.wsgi = lambda env, start_resp: start_resp()

+ handler.connections = [object()]

+ handler.shutdown.return_value = helpers.create_future(loop)

+ handler.shutdown.return_value.set_result(1)

+

+ yield from worker.close()

+ handler.shutdown.assert_called_with(timeout=95.0)