uvloop-0.8.1/ 0000775 0003720 0003720 00000000000 13156037661 013716 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/MANIFEST.in 0000664 0003720 0003720 00000000566 13156036740 015460 0 ustar travis travis 0000000 0000000 recursive-include docs *.py *.rst
recursive-include examples *.py
recursive-include tests *.py *.pem
recursive-include uvloop *.pyx *.pxd *.pxi *.py *.c *.h
recursive-include vendor/libuv *
recursive-exclude vendor/libuv/.git *
recursive-exclude vendor/libuv/docs *
recursive-exclude vendor/libuv/img *
include LICENSE-MIT LICENSE-APACHE README.rst Makefile performance.png
uvloop-0.8.1/LICENSE-MIT 0000664 0003720 0003720 00000002115 13156036740 015346 0 ustar travis travis 0000000 0000000 The MIT License
Copyright (c) 2015-present MagicStack Inc. http://magic.io
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
uvloop-0.8.1/README.rst 0000664 0003720 0003720 00000004055 13156036740 015406 0 ustar travis travis 0000000 0000000 .. image:: https://travis-ci.org/MagicStack/uvloop.svg?branch=master
:target: https://travis-ci.org/MagicStack/uvloop
.. image:: https://img.shields.io/pypi/v/uvloop.svg
:target: https://pypi.python.org/pypi/uvloop
uvloop is a fast, drop-in replacement of the built-in asyncio
event loop. uvloop is implemented in Cython and uses libuv
under the hood.
The project documentation can be found
`here `_. Please also check out the
`wiki `_.
Performance
-----------
uvloop makes asyncio 2-4x faster.
.. image:: performance.png
:target: http://magic.io/blog/uvloop-blazing-fast-python-networking/
The above chart shows the performance of an echo server with different
message sizes. The *sockets* benchmark uses ``loop.sock_recv()`` and
``loop.sock_sendall()`` methods; the *streams* benchmark uses asyncio
high-level streams, created by the ``asyncio.start_server()`` function;
and the *protocol* benchmark uses ``loop.create_server()`` with a simple
echo protocol. Read more about uvloop
`performance `_.
Installation
------------
uvloop requires Python 3.5 and is available on PyPI.
Use pip to install it::
$ pip install uvloop
Using uvloop
------------
To make asyncio use uvloop, you can install the uvloop event
loop policy:
.. code:: python
import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
Alternatively, you can create an instance of the loop
manually, using:
.. code:: python
loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
Development of uvloop
---------------------
To build uvloop, you'll need Cython and Python 3.5. The best way
is to create a virtual env, so that you'll have ``cython`` and
``python`` commands pointing to the correct tools.
1. ``git clone --recursive git@github.com:MagicStack/uvloop.git``
2. ``cd uvloop``
3. ``make``
4. ``make test``
License
-------
uvloop is dual-licensed under MIT and Apache 2.0 licenses.
uvloop-0.8.1/LICENSE-APACHE 0000664 0003720 0003720 00000025006 13156036740 015642 0 ustar travis travis 0000000 0000000 Copyright (c) 2015-present MagicStack Inc. http://magic.io
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
uvloop-0.8.1/tests/ 0000775 0003720 0003720 00000000000 13156037661 015060 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/tests/test_futures.py 0000664 0003720 0003720 00000036515 13156036740 020175 0 ustar travis travis 0000000 0000000 # LICENSE: PSF.
import asyncio
import concurrent.futures
import re
import sys
import threading
import unittest
import uvloop
from asyncio import test_utils
from uvloop import _testbase as tb
from unittest import mock
from test import support
# Most of the tests are copied from asyncio
def _fakefunc(f):
return f
def first_cb():
pass
def last_cb():
pass
class _TestFutures:
def create_future(self):
raise NotImplementedError
def test_future_initial_state(self):
f = self.create_future()
self.assertFalse(f.cancelled())
self.assertFalse(f.done())
f.cancel()
self.assertTrue(f.cancelled())
def test_future_cancel(self):
f = self.create_future()
self.assertTrue(f.cancel())
self.assertTrue(f.cancelled())
self.assertTrue(f.done())
self.assertRaises(asyncio.CancelledError, f.result)
self.assertRaises(asyncio.CancelledError, f.exception)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_result(self):
f = self.create_future()
self.assertRaises(asyncio.InvalidStateError, f.result)
f.set_result(42)
self.assertFalse(f.cancelled())
self.assertTrue(f.done())
self.assertEqual(f.result(), 42)
self.assertEqual(f.exception(), None)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_exception(self):
exc = RuntimeError()
f = self.create_future()
self.assertRaises(asyncio.InvalidStateError, f.exception)
if sys.version_info[:3] > (3, 5, 1):
# StopIteration cannot be raised into a Future - CPython issue26221
self.assertRaisesRegex(TypeError,
"StopIteration .* cannot be raised",
f.set_exception, StopIteration)
f.set_exception(exc)
self.assertFalse(f.cancelled())
self.assertTrue(f.done())
self.assertRaises(RuntimeError, f.result)
self.assertEqual(f.exception(), exc)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_exception_class(self):
f = self.create_future()
f.set_exception(RuntimeError)
self.assertIsInstance(f.exception(), RuntimeError)
def test_future_yield_from_twice(self):
f = self.create_future()
def fixture():
yield 'A'
x = yield from f
yield 'B', x
y = yield from f
yield 'C', y
g = fixture()
self.assertEqual(next(g), 'A') # yield 'A'.
self.assertEqual(next(g), f) # First yield from f.
f.set_result(42)
self.assertEqual(next(g), ('B', 42)) # yield 'B', x.
# The second "yield from f" does not yield f.
self.assertEqual(next(g), ('C', 42)) # yield 'C', y.
def test_future_repr(self):
self.loop.set_debug(True)
f_pending_debug = self.create_future()
frame = f_pending_debug._source_traceback[-1]
self.assertEqual(repr(f_pending_debug),
''
% (frame[0], frame[1]))
f_pending_debug.cancel()
self.loop.set_debug(False)
f_pending = self.create_future()
self.assertEqual(repr(f_pending), '')
f_pending.cancel()
f_cancelled = self.create_future()
f_cancelled.cancel()
self.assertEqual(repr(f_cancelled), '')
f_result = self.create_future()
f_result.set_result(4)
self.assertEqual(repr(f_result), '')
self.assertEqual(f_result.result(), 4)
exc = RuntimeError()
f_exception = self.create_future()
f_exception.set_exception(exc)
self.assertEqual(repr(f_exception),
'')
self.assertIs(f_exception.exception(), exc)
def func_repr(func):
filename, lineno = test_utils.get_function_source(func)
text = '%s() at %s:%s' % (func.__qualname__, filename, lineno)
return re.escape(text)
f_one_callbacks = self.create_future()
f_one_callbacks.add_done_callback(_fakefunc)
fake_repr = func_repr(_fakefunc)
self.assertRegex(repr(f_one_callbacks),
r'' % fake_repr)
f_one_callbacks.cancel()
self.assertEqual(repr(f_one_callbacks),
'')
f_two_callbacks = self.create_future()
f_two_callbacks.add_done_callback(first_cb)
f_two_callbacks.add_done_callback(last_cb)
first_repr = func_repr(first_cb)
last_repr = func_repr(last_cb)
self.assertRegex(repr(f_two_callbacks),
r''
% (first_repr, last_repr))
f_many_callbacks = self.create_future()
f_many_callbacks.add_done_callback(first_cb)
for i in range(8):
f_many_callbacks.add_done_callback(_fakefunc)
f_many_callbacks.add_done_callback(last_cb)
cb_regex = r'%s, <8 more>, %s' % (first_repr, last_repr)
self.assertRegex(repr(f_many_callbacks),
r'' % cb_regex)
f_many_callbacks.cancel()
self.assertEqual(repr(f_many_callbacks),
'')
def test_future_copy_state(self):
if sys.version_info[:3] < (3, 5, 1):
raise unittest.SkipTest()
from asyncio.futures import _copy_future_state
f = self.create_future()
f.set_result(10)
newf = self.create_future()
_copy_future_state(f, newf)
self.assertTrue(newf.done())
self.assertEqual(newf.result(), 10)
f_exception = self.create_future()
f_exception.set_exception(RuntimeError())
newf_exception = self.create_future()
_copy_future_state(f_exception, newf_exception)
self.assertTrue(newf_exception.done())
self.assertRaises(RuntimeError, newf_exception.result)
f_cancelled = self.create_future()
f_cancelled.cancel()
newf_cancelled = self.create_future()
_copy_future_state(f_cancelled, newf_cancelled)
self.assertTrue(newf_cancelled.cancelled())
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_abandoned(self, m_log):
fut = self.create_future()
del fut
self.assertFalse(m_log.error.called)
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_result_unretrieved(self, m_log):
fut = self.create_future()
fut.set_result(42)
del fut
self.assertFalse(m_log.error.called)
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_result_retrieved(self, m_log):
fut = self.create_future()
fut.set_result(42)
fut.result()
del fut
self.assertFalse(m_log.error.called)
def test_future_wrap_future(self):
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = asyncio.wrap_future(f1, loop=self.loop)
res, ident = self.loop.run_until_complete(f2)
self.assertIsInstance(f2, asyncio.Future)
self.assertEqual(res, 'oi')
self.assertNotEqual(ident, threading.get_ident())
def test_future_wrap_future_future(self):
f1 = self.create_future()
f2 = asyncio.wrap_future(f1)
self.assertIs(f1, f2)
def test_future_wrap_future_use_global_loop(self):
with mock.patch('asyncio.futures.events') as events:
events.get_event_loop = lambda: self.loop
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = asyncio.wrap_future(f1)
self.assertIs(self.loop, f2._loop)
def test_future_wrap_future_cancel(self):
f1 = concurrent.futures.Future()
f2 = asyncio.wrap_future(f1, loop=self.loop)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertTrue(f1.cancelled())
self.assertTrue(f2.cancelled())
def test_future_wrap_future_cancel2(self):
f1 = concurrent.futures.Future()
f2 = asyncio.wrap_future(f1, loop=self.loop)
f1.set_result(42)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertFalse(f1.cancelled())
self.assertEqual(f1.result(), 42)
self.assertTrue(f2.cancelled())
def test_future_source_traceback(self):
self.loop.set_debug(True)
future = self.create_future()
lineno = sys._getframe().f_lineno - 1
self.assertIsInstance(future._source_traceback, list)
self.assertEqual(future._source_traceback[-2][:3],
(__file__,
lineno,
'test_future_source_traceback'))
def check_future_exception_never_retrieved(self, debug):
last_ctx = None
def handler(loop, context):
nonlocal last_ctx
last_ctx = context
self.loop.set_debug(debug)
self.loop.set_exception_handler(handler)
def memory_error():
try:
raise MemoryError()
except BaseException as exc:
return exc
exc = memory_error()
future = self.create_future()
if debug:
source_traceback = future._source_traceback
future.set_exception(exc)
future = None
support.gc_collect()
test_utils.run_briefly(self.loop)
self.assertIsNotNone(last_ctx)
self.assertIs(last_ctx['exception'], exc)
self.assertEqual(last_ctx['message'],
'Future exception was never retrieved')
if debug:
tb = last_ctx['source_traceback']
self.assertEqual(tb[-2].name,
'check_future_exception_never_retrieved')
def test_future_exception_never_retrieved(self):
self.check_future_exception_never_retrieved(False)
def test_future_exception_never_retrieved_debug(self):
self.check_future_exception_never_retrieved(True)
def test_future_wrap_future(self):
from uvloop.loop import _wrap_future
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = _wrap_future(f1, loop=self.loop)
res, ident = self.loop.run_until_complete(f2)
self.assertIsInstance(f2, asyncio.Future)
self.assertEqual(res, 'oi')
self.assertNotEqual(ident, threading.get_ident())
def test_future_wrap_future_future(self):
from uvloop.loop import _wrap_future
f1 = self.create_future()
f2 = _wrap_future(f1)
self.assertIs(f1, f2)
def test_future_wrap_future_cancel(self):
from uvloop.loop import _wrap_future
f1 = concurrent.futures.Future()
f2 = _wrap_future(f1, loop=self.loop)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertTrue(f1.cancelled())
self.assertTrue(f2.cancelled())
def test_future_wrap_future_cancel2(self):
from uvloop.loop import _wrap_future
f1 = concurrent.futures.Future()
f2 = _wrap_future(f1, loop=self.loop)
f1.set_result(42)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertFalse(f1.cancelled())
self.assertEqual(f1.result(), 42)
self.assertTrue(f2.cancelled())
class _TestFuturesDoneCallbacks:
def run_briefly(self):
test_utils.run_briefly(self.loop)
def _make_callback(self, bag, thing):
# Create a callback function that appends thing to bag.
def bag_appender(future):
bag.append(thing)
return bag_appender
def _new_future(self):
raise NotImplementedError
def test_future_callbacks_invoked_on_set_result(self):
bag = []
f = self._new_future()
f.add_done_callback(self._make_callback(bag, 42))
f.add_done_callback(self._make_callback(bag, 17))
self.assertEqual(bag, [])
f.set_result('foo')
self.run_briefly()
self.assertEqual(bag, [42, 17])
self.assertEqual(f.result(), 'foo')
def test_future_callbacks_invoked_on_set_exception(self):
bag = []
f = self._new_future()
f.add_done_callback(self._make_callback(bag, 100))
self.assertEqual(bag, [])
exc = RuntimeError()
f.set_exception(exc)
self.run_briefly()
self.assertEqual(bag, [100])
self.assertEqual(f.exception(), exc)
def test_future_remove_done_callback(self):
bag = []
f = self._new_future()
cb1 = self._make_callback(bag, 1)
cb2 = self._make_callback(bag, 2)
cb3 = self._make_callback(bag, 3)
# Add one cb1 and one cb2.
f.add_done_callback(cb1)
f.add_done_callback(cb2)
# One instance of cb2 removed. Now there's only one cb1.
self.assertEqual(f.remove_done_callback(cb2), 1)
# Never had any cb3 in there.
self.assertEqual(f.remove_done_callback(cb3), 0)
# After this there will be 6 instances of cb1 and one of cb2.
f.add_done_callback(cb2)
for i in range(5):
f.add_done_callback(cb1)
# Remove all instances of cb1. One cb2 remains.
self.assertEqual(f.remove_done_callback(cb1), 6)
self.assertEqual(bag, [])
f.set_result('foo')
self.run_briefly()
self.assertEqual(bag, [2])
self.assertEqual(f.result(), 'foo')
###############################################################################
# Tests Matrix
###############################################################################
class Test_UV_UV_create_future(_TestFutures, tb.UVTestCase):
# Test uvloop.Loop.create_future
def create_future(self):
return self.loop.create_future()
class Test_UV_UV_Future(_TestFutures, tb.UVTestCase):
# Test that uvloop.Future can be instantiated directly
def create_future(self):
return uvloop.Future(loop=self.loop)
class Test_UV_AIO_Futures(_TestFutures, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
class Test_AIO_Futures(_TestFutures, tb.AIOTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
class Test_UV_UV_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.UVTestCase):
def _new_future(self):
return self.loop.create_future()
class Test_UV_AIO_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.UVTestCase):
def _new_future(self):
return asyncio.Future(loop=self.loop)
class Test_AIO_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.AIOTestCase):
def _new_future(self):
return asyncio.Future(loop=self.loop)
uvloop-0.8.1/tests/test_sockets.py 0000664 0003720 0003720 00000010661 13156036740 020145 0 ustar travis travis 0000000 0000000 import asyncio
import select
import socket
import sys
import unittest
from uvloop import _testbase as tb
_SIZE = 1024 * 1024
class _TestSockets:
async def recv_all(self, sock, nbytes):
buf = b''
while len(buf) < nbytes:
buf += await self.loop.sock_recv(sock, nbytes - len(buf))
return buf
def test_socket_connect_recv_send(self):
if self.is_asyncio_loop() and sys.version_info[:3] == (3, 5, 2):
# See https://github.com/python/asyncio/pull/366 for details.
raise unittest.SkipTest()
def srv_gen():
yield tb.write(b'helo')
data = yield tb.read(4 * _SIZE)
self.assertEqual(data, b'ehlo' * _SIZE)
yield tb.write(b'O')
yield tb.write(b'K')
# We use @asyncio.coroutine & `yield from` to test
# the compatibility of Cython's 'async def' coroutines.
@asyncio.coroutine
def client(sock, addr):
yield from self.loop.sock_connect(sock, addr)
data = yield from self.recv_all(sock, 4)
self.assertEqual(data, b'helo')
yield from self.loop.sock_sendall(sock, b'ehlo' * _SIZE)
data = yield from self.recv_all(sock, 2)
self.assertEqual(data, b'OK')
with tb.tcp_server(srv_gen) as srv:
sock = socket.socket()
with sock:
sock.setblocking(False)
self.loop.run_until_complete(client(sock, srv.addr))
def test_socket_accept_recv_send(self):
async def server():
sock = socket.socket()
sock.setblocking(False)
with sock:
sock.bind(('127.0.0.1', 0))
sock.listen()
fut = self.loop.run_in_executor(None, client,
sock.getsockname())
client_sock, _ = await self.loop.sock_accept(sock)
with client_sock:
data = await self.recv_all(client_sock, _SIZE)
self.assertEqual(data, b'a' * _SIZE)
await fut
def client(addr):
sock = socket.socket()
with sock:
sock.connect(addr)
sock.sendall(b'a' * _SIZE)
self.loop.run_until_complete(server())
def test_socket_failed_connect(self):
sock = socket.socket()
with sock:
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def run():
sock = socket.socket()
with sock:
sock.setblocking(False)
with self.assertRaises(ConnectionRefusedError):
await self.loop.sock_connect(sock, addr)
self.loop.run_until_complete(run())
def test_socket_blocking_error(self):
self.loop.set_debug(True)
sock = socket.socket()
with sock:
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_recv(sock, 0))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_sendall(sock, b''))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_accept(sock))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_connect(sock, (b'', 0)))
class TestUVSockets(_TestSockets, tb.UVTestCase):
@unittest.skipUnless(hasattr(select, 'epoll'), 'Linux only test')
def test_socket_sync_remove(self):
# See https://github.com/MagicStack/uvloop/issues/61 for details
sock = socket.socket()
epoll = select.epoll.fromfd(self.loop._get_backend_id())
try:
cb = lambda: None
sock.bind(('127.0.0.1', 0))
sock.listen(0)
fd = sock.fileno()
self.loop.add_reader(fd, cb)
self.loop.run_until_complete(asyncio.sleep(0.01, loop=self.loop))
self.loop.remove_reader(fd)
with self.assertRaises(FileNotFoundError):
epoll.modify(fd, 0)
finally:
sock.close()
self.loop.close()
epoll.close()
class TestAIOSockets(_TestSockets, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_process.py 0000664 0003720 0003720 00000050272 13156036740 020152 0 ustar travis travis 0000000 0000000 import asyncio
import contextlib
import os
import signal
import subprocess
import sys
import tempfile
import time
from asyncio import test_utils
from uvloop import _testbase as tb
class _TestProcess:
def test_process_env_1(self):
async def test():
cmd = 'echo $FOO$BAR'
env = {'FOO': 'sp', 'BAR': 'am'}
proc = await asyncio.create_subprocess_shell(
cmd,
env=env,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
out, _ = await proc.communicate()
self.assertEqual(out, b'spam\n')
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
def test_process_cwd_1(self):
async def test():
cmd = 'pwd'
env = {}
cwd = '/'
proc = await asyncio.create_subprocess_shell(
cmd,
cwd=cwd,
env=env,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
out, _ = await proc.communicate()
self.assertEqual(out, b'/\n')
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
def test_process_preexec_fn_1(self):
# Copied from CPython/test_suprocess.py
# DISCLAIMER: Setting environment variables is *not* a good use
# of a preexec_fn. This is merely a test.
async def test():
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, '-c',
'import os,sys;sys.stdout.write(os.getenv("FRUIT"))',
stdout=subprocess.PIPE,
preexec_fn=lambda: os.putenv("FRUIT", "apple"),
loop=self.loop)
out, _ = await proc.communicate()
self.assertEqual(out, b'apple')
self.assertEqual(proc.returncode, 0)
self.loop.run_until_complete(test())
def test_process_preexec_fn_2(self):
# Copied from CPython/test_suprocess.py
def raise_it():
raise ValueError("spam")
async def test():
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, '-c', 'import time; time.sleep(10)',
preexec_fn=raise_it,
loop=self.loop)
await proc.communicate()
started = time.time()
try:
self.loop.run_until_complete(test())
except subprocess.SubprocessError as ex:
self.assertIn('preexec_fn', ex.args[0])
if ex.__cause__ is not None:
# uvloop will set __cause__
self.assertIs(type(ex.__cause__), ValueError)
self.assertEqual(ex.__cause__.args[0], 'spam')
else:
self.fail(
'exception in preexec_fn did not propagate to the parent')
if time.time() - started > 5:
self.fail(
'exception in preexec_fn did not kill the child process')
def test_process_executable_1(self):
async def test():
proc = await asyncio.create_subprocess_exec(
b'doesnotexist', b'-c', b'print("spam")',
executable=sys.executable,
stdout=subprocess.PIPE,
loop=self.loop)
out, err = await proc.communicate()
self.assertEqual(out, b'spam\n')
self.loop.run_until_complete(test())
def test_process_pid_1(self):
async def test():
prog = '''\
import os
print(os.getpid())
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
pid = proc.pid
expected_result = '{}\n'.format(pid).encode()
out, err = await proc.communicate()
self.assertEqual(out, expected_result)
self.loop.run_until_complete(test())
def test_process_send_signal_1(self):
async def test():
prog = '''\
import signal
def handler(signum, frame):
if signum == signal.SIGUSR1:
print('WORLD')
signal.signal(signal.SIGUSR1, handler)
a = input()
print(a)
a = input()
print(a)
exit(11)
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
proc.stdin.write(b'HELLO\n')
await proc.stdin.drain()
self.assertEqual(await proc.stdout.readline(), b'HELLO\n')
proc.send_signal(signal.SIGUSR1)
proc.stdin.write(b'!\n')
await proc.stdin.drain()
self.assertEqual(await proc.stdout.readline(), b'WORLD\n')
self.assertEqual(await proc.stdout.readline(), b'!\n')
self.assertEqual(await proc.wait(), 11)
self.loop.run_until_complete(test())
def test_process_streams_basic_1(self):
async def test():
prog = '''\
import sys
while True:
a = input()
if a == 'stop':
exit(20)
elif a == 'stderr':
print('OUCH', file=sys.stderr)
else:
print('>' + a + '<')
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
self.assertGreater(proc.pid, 0)
self.assertIs(proc.returncode, None)
transp = proc._transport
with self.assertRaises(NotImplementedError):
# stdin is WriteTransport
transp.get_pipe_transport(0).pause_reading()
with self.assertRaises((NotImplementedError, AttributeError)):
# stdout is ReadTransport
transp.get_pipe_transport(1).write(b'wat')
proc.stdin.write(b'foobar\n')
await proc.stdin.drain()
out = await proc.stdout.readline()
self.assertEqual(out, b'>foobar<\n')
proc.stdin.write(b'stderr\n')
await proc.stdin.drain()
out = await proc.stderr.readline()
self.assertEqual(out, b'OUCH\n')
proc.stdin.write(b'stop\n')
await proc.stdin.drain()
exitcode = await proc.wait()
self.assertEqual(exitcode, 20)
self.loop.run_until_complete(test())
def test_process_streams_stderr_to_stdout(self):
async def test():
prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(err)
self.assertEqual(out, b'out\nerr\n')
self.loop.run_until_complete(test())
def test_process_streams_devnull(self):
async def test():
prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(err)
self.assertIsNone(out)
self.loop.run_until_complete(test())
def test_process_streams_pass_fds(self):
async def test():
prog = '''\
import sys, os
assert sys.argv[1] == '--'
inherited = int(sys.argv[2])
non_inherited = int(sys.argv[3])
os.fstat(inherited)
try:
os.fstat(non_inherited)
except:
pass
else:
raise RuntimeError()
print("OK")
'''
with tempfile.TemporaryFile() as inherited, \
tempfile.TemporaryFile() as non_inherited:
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog, '--',
str(inherited.fileno()),
str(non_inherited.fileno()),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
pass_fds=(inherited.fileno(),),
loop=self.loop)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(out, b'OK\n')
self.loop.run_until_complete(test())
class _AsyncioTests:
# Program blocking
PROGRAM_BLOCKED = [sys.executable, '-c', 'import time; time.sleep(3600)']
# Program copying input to output
PROGRAM_CAT = [
sys.executable, '-c',
';'.join(('import sys',
'data = sys.stdin.buffer.read()',
'sys.stdout.buffer.write(data)'))]
def test_stdin_not_inheritable(self):
# asyncio issue #209: stdin must not be inheritable, otherwise
# the Process.communicate() hangs
@asyncio.coroutine
def len_message(message):
code = 'import sys; data = sys.stdin.read(); print(len(data))'
proc = yield from asyncio.create_subprocess_exec(
sys.executable, '-c', code,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
close_fds=False,
loop=self.loop)
stdout, stderr = yield from proc.communicate(message)
exitcode = yield from proc.wait()
return (stdout, exitcode)
output, exitcode = self.loop.run_until_complete(len_message(b'abc'))
self.assertEqual(output.rstrip(), b'3')
self.assertEqual(exitcode, 0)
def test_stdin_stdout(self):
args = self.PROGRAM_CAT
@asyncio.coroutine
def run(data):
proc = yield from asyncio.create_subprocess_exec(
*args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
# feed data
proc.stdin.write(data)
yield from proc.stdin.drain()
proc.stdin.close()
# get output and exitcode
data = yield from proc.stdout.read()
exitcode = yield from proc.wait()
return (exitcode, data)
task = run(b'some data')
task = asyncio.wait_for(task, 60.0, loop=self.loop)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
self.assertEqual(stdout, b'some data')
def test_communicate(self):
args = self.PROGRAM_CAT
@asyncio.coroutine
def run(data):
proc = yield from asyncio.create_subprocess_exec(
*args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
stdout, stderr = yield from proc.communicate(data)
return proc.returncode, stdout
task = run(b'some data')
task = asyncio.wait_for(task, 60.0, loop=self.loop)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
self.assertEqual(stdout, b'some data')
def test_start_new_session(self):
# start the new process in a new session
create = asyncio.create_subprocess_shell('exit 8',
start_new_session=True,
loop=self.loop)
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 8)
def test_shell(self):
create = asyncio.create_subprocess_shell('exit 7',
loop=self.loop)
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 7)
def test_kill(self):
args = self.PROGRAM_BLOCKED
create = asyncio.create_subprocess_exec(*args, loop=self.loop)
proc = self.loop.run_until_complete(create)
proc.kill()
returncode = self.loop.run_until_complete(proc.wait())
self.assertEqual(-signal.SIGKILL, returncode)
def test_terminate(self):
args = self.PROGRAM_BLOCKED
create = asyncio.create_subprocess_exec(*args, loop=self.loop)
proc = self.loop.run_until_complete(create)
proc.terminate()
returncode = self.loop.run_until_complete(proc.wait())
self.assertEqual(-signal.SIGTERM, returncode)
def test_send_signal(self):
code = 'import time; print("sleeping", flush=True); time.sleep(3600)'
args = [sys.executable, '-c', code]
create = asyncio.create_subprocess_exec(*args,
stdout=subprocess.PIPE,
loop=self.loop)
proc = self.loop.run_until_complete(create)
@asyncio.coroutine
def send_signal(proc):
# basic synchronization to wait until the program is sleeping
line = yield from proc.stdout.readline()
self.assertEqual(line, b'sleeping\n')
proc.send_signal(signal.SIGHUP)
returncode = (yield from proc.wait())
return returncode
returncode = self.loop.run_until_complete(send_signal(proc))
self.assertEqual(-signal.SIGHUP, returncode)
def test_cancel_process_wait(self):
# Issue #23140: cancel Process.wait()
@asyncio.coroutine
def cancel_wait():
proc = yield from asyncio.create_subprocess_exec(
*self.PROGRAM_BLOCKED,
loop=self.loop)
# Create an internal future waiting on the process exit
task = self.loop.create_task(proc.wait())
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# Cancel the future
task.cancel()
# Kill the process and wait until it is done
proc.kill()
yield from proc.wait()
self.loop.run_until_complete(cancel_wait())
def test_cancel_make_subprocess_transport_exec(self):
@asyncio.coroutine
def cancel_make_transport():
coro = asyncio.create_subprocess_exec(*self.PROGRAM_BLOCKED,
loop=self.loop)
task = self.loop.create_task(coro)
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# ignore the log:
# "Exception during subprocess creation, kill the subprocess"
with test_utils.disable_logger():
self.loop.run_until_complete(cancel_make_transport())
def test_cancel_post_init(self):
@asyncio.coroutine
def cancel_make_transport():
coro = self.loop.subprocess_exec(asyncio.SubprocessProtocol,
*self.PROGRAM_BLOCKED)
task = self.loop.create_task(coro)
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# ignore the log:
# "Exception during subprocess creation, kill the subprocess"
with test_utils.disable_logger():
self.loop.run_until_complete(cancel_make_transport())
test_utils.run_briefly(self.loop)
class Test_UV_Process(_TestProcess, tb.UVTestCase):
def test_process_lated_stdio_init(self):
class TestProto:
def __init__(self):
self.lost = 0
self.stages = []
def connection_made(self, transport):
self.stages.append(('CM', transport))
def pipe_data_received(self, fd, data):
if fd == 1:
self.stages.append(('STDOUT', data))
def pipe_connection_lost(self, fd, exc):
if fd == 1:
self.stages.append(('STDOUT', 'LOST'))
def process_exited(self):
self.stages.append('PROC_EXIT')
def connection_lost(self, exc):
self.stages.append(('CL', self.lost, exc))
self.lost += 1
async def run(**kwargs):
return await self.loop.subprocess_shell(
lambda: TestProto(),
'echo 1',
**kwargs)
with self.subTest('paused, stdin pipe'):
transport, proto = self.loop.run_until_complete(
run(stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
__uvloop_sleep_after_fork=True))
self.assertIsNot(transport, None)
self.assertEqual(transport.get_returncode(), 0)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
with self.subTest('paused, no stdin'):
transport, proto = self.loop.run_until_complete(
run(stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
__uvloop_sleep_after_fork=True))
self.assertIsNot(transport, None)
self.assertEqual(transport.get_returncode(), 0)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
with self.subTest('no pause, no stdin'):
transport, proto = self.loop.run_until_complete(
run(stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE))
self.loop.run_until_complete(transport._wait())
self.assertEqual(transport.get_returncode(), 0)
self.assertIsNot(transport, None)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
def test_process_streams_redirect(self):
# This won't work for asyncio implementation of subprocess
async def test():
prog = bR'''
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(out)
self.assertIsNone(err)
with tempfile.NamedTemporaryFile('w') as stdout:
with tempfile.NamedTemporaryFile('w') as stderr:
with contextlib.redirect_stdout(stdout):
with contextlib.redirect_stderr(stderr):
self.loop.run_until_complete(test())
stdout.flush()
stderr.flush()
with open(stdout.name, 'rb') as so:
self.assertEqual(so.read(), b'out\n')
with open(stderr.name, 'rb') as se:
self.assertEqual(se.read(), b'err\n')
class Test_AIO_Process(_TestProcess, tb.AIOTestCase):
pass
class TestAsyncio_UV_Process(_AsyncioTests, tb.UVTestCase):
pass
class TestAsyncio_AIO_Process(_AsyncioTests, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_testbase.py 0000664 0003720 0003720 00000002536 13156036740 020306 0 ustar travis travis 0000000 0000000 import unittest
from uvloop import _testbase as tb
class TestBaseTest(unittest.TestCase):
def test_duplicate_methods(self):
with self.assertRaisesRegex(RuntimeError, 'duplicate test Foo.test_a'):
class Foo(tb.BaseTestCase):
def test_a(self):
pass
def test_b(self):
pass
def test_a(self): # NOQA
pass
def test_duplicate_methods_parent_1(self):
class FooBase:
def test_a(self):
pass
with self.assertRaisesRegex(RuntimeError,
'duplicate test Foo.test_a.*'
'defined in FooBase'):
class Foo(FooBase, tb.BaseTestCase):
def test_b(self):
pass
def test_a(self):
pass
def test_duplicate_methods_parent_2(self):
class FooBase(tb.BaseTestCase):
def test_a(self):
pass
with self.assertRaisesRegex(RuntimeError,
'duplicate test Foo.test_a.*'
'defined in FooBase'):
class Foo(FooBase):
def test_b(self):
pass
def test_a(self):
pass
uvloop-0.8.1/tests/test_dns.py 0000664 0003720 0003720 00000013163 13156036740 017256 0 ustar travis travis 0000000 0000000 import socket
import unittest
from uvloop import _testbase as tb
class BaseTestDNS:
def _test_getaddrinfo(self, *args, **kwargs):
err = None
try:
a1 = socket.getaddrinfo(*args, **kwargs)
except socket.gaierror as ex:
err = ex
try:
a2 = self.loop.run_until_complete(
self.loop.getaddrinfo(*args, **kwargs))
except socket.gaierror as ex:
if err is not None:
self.assertEqual(ex.args, err.args)
else:
ex.__context__ = err
raise ex
except OSError as ex:
ex.__context__ = err
raise ex
else:
if err is not None:
raise err
self.assertEqual(a1, a2)
def _test_getnameinfo(self, *args, **kwargs):
err = None
try:
a1 = socket.getnameinfo(*args, **kwargs)
except Exception as ex:
err = ex
try:
a2 = self.loop.run_until_complete(
self.loop.getnameinfo(*args, **kwargs))
except Exception as ex:
if err is not None:
if ex.__class__ is not err.__class__:
print(ex, err)
self.assertIs(ex.__class__, err.__class__)
self.assertEqual(ex.args, err.args)
else:
raise
else:
if err is not None:
raise err
self.assertEqual(a1, a2)
def test_getaddrinfo_1(self):
self._test_getaddrinfo('example.com', 80)
self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM)
def test_getaddrinfo_2(self):
self._test_getaddrinfo('example.com', 80, flags=socket.AI_CANONNAME)
def test_getaddrinfo_3(self):
self._test_getaddrinfo('a' + '1' * 50 + '.wat', 800)
def test_getaddrinfo_4(self):
self._test_getaddrinfo('example.com', 80, family=-1)
self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM,
family=-1)
def test_getaddrinfo_5(self):
self._test_getaddrinfo('example.com', '80')
self._test_getaddrinfo('example.com', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_6(self):
self._test_getaddrinfo(b'example.com', b'80')
self._test_getaddrinfo(b'example.com', b'80', type=socket.SOCK_STREAM)
def test_getaddrinfo_7(self):
self._test_getaddrinfo(None, 0)
self._test_getaddrinfo(None, 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_8(self):
self._test_getaddrinfo('', 0)
self._test_getaddrinfo('', 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_9(self):
self._test_getaddrinfo(b'', 0)
self._test_getaddrinfo(b'', 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_10(self):
self._test_getaddrinfo(None, None)
self._test_getaddrinfo(None, None, type=socket.SOCK_STREAM)
def test_getaddrinfo_11(self):
self._test_getaddrinfo(b'example.com', '80')
self._test_getaddrinfo(b'example.com', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_12(self):
self._test_getaddrinfo('127.0.0.1', '80')
self._test_getaddrinfo('127.0.0.1', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_13(self):
self._test_getaddrinfo(b'127.0.0.1', b'80')
self._test_getaddrinfo(b'127.0.0.1', b'80', type=socket.SOCK_STREAM)
def test_getaddrinfo_14(self):
self._test_getaddrinfo(b'127.0.0.1', b'http')
self._test_getaddrinfo(b'127.0.0.1', b'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_15(self):
self._test_getaddrinfo('127.0.0.1', 'http')
self._test_getaddrinfo('127.0.0.1', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_16(self):
self._test_getaddrinfo('localhost', 'http')
self._test_getaddrinfo('localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_17(self):
self._test_getaddrinfo(b'localhost', 'http')
self._test_getaddrinfo(b'localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_18(self):
self._test_getaddrinfo('localhost', b'http')
self._test_getaddrinfo('localhost', b'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_19(self):
self._test_getaddrinfo('::1', 80)
self._test_getaddrinfo('::1', 80, type=socket.SOCK_STREAM)
def test_getaddrinfo_20(self):
self._test_getaddrinfo('127.0.0.1', 80)
self._test_getaddrinfo('127.0.0.1', 80, type=socket.SOCK_STREAM)
######
def test_getnameinfo_1(self):
self._test_getnameinfo(('127.0.0.1', 80), 0)
def test_getnameinfo_2(self):
self._test_getnameinfo(('127.0.0.1', 80, 1231231231213), 0)
def test_getnameinfo_3(self):
self._test_getnameinfo(('127.0.0.1', 80, 0, 0), 0)
def test_getnameinfo_4(self):
self._test_getnameinfo(('::1', 80), 0)
def test_getnameinfo_5(self):
self._test_getnameinfo(('localhost', 8080), 0)
class Test_UV_DNS(BaseTestDNS, tb.UVTestCase):
def test_getaddrinfo_close_loop(self):
# Test that we can close the loop with a running
# DNS query.
try:
# Check that we have internet connection
socket.getaddrinfo('example.com', 80)
except socket.error:
raise unittest.SkipTest
async def run():
fut = self.loop.getaddrinfo('example.com', 80)
fut.cancel()
self.loop.stop()
try:
self.loop.run_until_complete(run())
finally:
self.loop.close()
class Test_AIO_DNS(BaseTestDNS, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_base.py 0000664 0003720 0003720 00000052200 13156036740 017377 0 ustar travis travis 0000000 0000000 import asyncio
import fcntl
import logging
import os
import threading
import time
import uvloop
import unittest
import weakref
from unittest import mock
from uvloop._testbase import UVTestCase, AIOTestCase
class _TestBase:
def test_close(self):
self.assertFalse(self.loop._closed)
self.assertFalse(self.loop.is_closed())
self.loop.close()
self.assertTrue(self.loop._closed)
self.assertTrue(self.loop.is_closed())
# it should be possible to call close() more than once
self.loop.close()
self.loop.close()
# operation blocked when the loop is closed
f = asyncio.Future(loop=self.loop)
self.assertRaises(RuntimeError, self.loop.run_forever)
self.assertRaises(RuntimeError, self.loop.run_until_complete, f)
def test_handle_weakref(self):
wd = weakref.WeakValueDictionary()
h = self.loop.call_soon(lambda: None)
wd['h'] = h # Would fail without __weakref__ slot.
def test_call_soon(self):
calls = []
def cb(inc):
calls.append(inc)
self.loop.stop()
self.loop.call_soon(cb, 10)
h = self.loop.call_soon(cb, 100)
self.assertIn('.cb', repr(h))
h.cancel()
self.assertIn('cancelled', repr(h))
self.loop.call_soon(cb, 1)
self.loop.run_forever()
self.assertEqual(calls, [10, 1])
def test_call_soon_base_exc(self):
def cb():
raise KeyboardInterrupt()
self.loop.call_soon(cb)
with self.assertRaises(KeyboardInterrupt):
self.loop.run_forever()
self.assertFalse(self.loop.is_closed())
def test_calls_debug_reporting(self):
def run_test(debug, meth, stack_adj):
context = None
def handler(loop, ctx):
nonlocal context
context = ctx
self.loop.set_debug(debug)
self.loop.set_exception_handler(handler)
def cb():
1 / 0
meth(cb)
self.assertIsNone(context)
self.loop.run_until_complete(asyncio.sleep(0.05, loop=self.loop))
self.assertIs(type(context['exception']), ZeroDivisionError)
self.assertTrue(context['message'].startswith(
'Exception in callback'))
if debug:
tb = context['source_traceback']
self.assertEqual(tb[-1 + stack_adj].name, 'run_test')
else:
self.assertFalse('source_traceback' in context)
del context
for debug in (True, False):
for meth_name, meth, stack_adj in (
('call_soon',
self.loop.call_soon, 0),
('call_later', # `-1` accounts for lambda
lambda *args: self.loop.call_later(0.01, *args), -1)
):
with self.subTest(debug=debug, meth_name=meth_name):
run_test(debug, meth, stack_adj)
def test_now_update(self):
async def run():
st = self.loop.time()
time.sleep(0.05)
return self.loop.time() - st
delta = self.loop.run_until_complete(run())
self.assertTrue(delta > 0.049 and delta < 0.6)
def test_call_later_1(self):
calls = []
def cb(inc=10, stop=False):
calls.append(inc)
self.assertTrue(self.loop.is_running())
if stop:
self.loop.call_soon(self.loop.stop)
self.loop.call_later(0.05, cb)
# canceled right away
h = self.loop.call_later(0.05, cb, 100, True)
self.assertIn('.cb', repr(h))
h.cancel()
self.assertIn('cancelled', repr(h))
self.loop.call_later(0.05, cb, 1, True)
self.loop.call_later(1000, cb, 1000) # shouldn't be called
started = time.monotonic()
self.loop.run_forever()
finished = time.monotonic()
self.assertEqual(calls, [10, 1])
self.assertFalse(self.loop.is_running())
self.assertLess(finished - started, 0.1)
self.assertGreater(finished - started, 0.04)
def test_call_later_2(self):
# Test that loop.call_later triggers an update of
# libuv cached time.
async def main():
await asyncio.sleep(0.001, loop=self.loop)
time.sleep(0.01)
await asyncio.sleep(0.01, loop=self.loop)
started = time.monotonic()
self.loop.run_until_complete(main())
delta = time.monotonic() - started
self.assertGreater(delta, 0.019)
def test_call_later_negative(self):
calls = []
def cb(arg):
calls.append(arg)
self.loop.stop()
self.loop.call_later(-1, cb, 'a')
self.loop.run_forever()
self.assertEqual(calls, ['a'])
def test_call_at(self):
if os.environ.get('TRAVIS_OS_NAME'):
# Time seems to be really unpredictable on Travis.
raise unittest.SkipTest('time is not monotonic on Travis')
i = 0
def cb(inc):
nonlocal i
i += inc
self.loop.stop()
at = self.loop.time() + 0.05
self.loop.call_at(at, cb, 100).cancel()
self.loop.call_at(at, cb, 10)
started = time.monotonic()
self.loop.run_forever()
finished = time.monotonic()
self.assertEqual(i, 10)
self.assertLess(finished - started, 0.07)
self.assertGreater(finished - started, 0.045)
def test_check_thread(self):
def check_thread(loop, debug):
def cb():
pass
loop.set_debug(debug)
if debug:
msg = ("Non-thread-safe operation invoked on an "
"event loop other than the current one")
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_soon(cb)
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_later(60, cb)
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_at(loop.time() + 60, cb)
else:
loop.call_soon(cb)
loop.call_later(60, cb)
loop.call_at(loop.time() + 60, cb)
def check_in_thread(loop, event, debug, create_loop, fut):
# wait until the event loop is running
event.wait()
try:
if create_loop:
loop2 = self.new_loop()
try:
asyncio.set_event_loop(loop2)
check_thread(loop, debug)
finally:
asyncio.set_event_loop(None)
loop2.close()
else:
check_thread(loop, debug)
except Exception as exc:
loop.call_soon_threadsafe(fut.set_exception, exc)
else:
loop.call_soon_threadsafe(fut.set_result, None)
def test_thread(loop, debug, create_loop=False):
event = threading.Event()
fut = asyncio.Future(loop=loop)
loop.call_soon(event.set)
args = (loop, event, debug, create_loop, fut)
thread = threading.Thread(target=check_in_thread, args=args)
thread.start()
loop.run_until_complete(fut)
thread.join()
# raise RuntimeError if the thread has no event loop
test_thread(self.loop, True)
# check disabled if debug mode is disabled
test_thread(self.loop, False)
# raise RuntimeError if the event loop of the thread is not the called
# event loop
test_thread(self.loop, True, create_loop=True)
# check disabled if debug mode is disabled
test_thread(self.loop, False, create_loop=True)
def test_run_once_in_executor_plain(self):
called = []
def cb(arg):
called.append(arg)
async def runner():
await self.loop.run_in_executor(None, cb, 'a')
self.loop.run_until_complete(runner())
self.assertEqual(called, ['a'])
def test_set_debug(self):
self.loop.set_debug(True)
self.assertTrue(self.loop.get_debug())
self.loop.set_debug(False)
self.assertFalse(self.loop.get_debug())
def test_run_until_complete_type_error(self):
self.assertRaises(
TypeError, self.loop.run_until_complete, 'blah')
def test_run_until_complete_loop(self):
task = asyncio.Future(loop=self.loop)
other_loop = self.new_loop()
self.addCleanup(other_loop.close)
self.assertRaises(
ValueError, other_loop.run_until_complete, task)
def test_run_until_complete_error(self):
async def foo():
raise ValueError('aaa')
with self.assertRaisesRegex(ValueError, 'aaa'):
self.loop.run_until_complete(foo())
def test_debug_slow_callbacks(self):
logger = logging.getLogger('asyncio')
self.loop.set_debug(True)
self.loop.slow_callback_duration = 0.2
self.loop.call_soon(lambda: time.sleep(0.3))
with mock.patch.object(logger, 'warning') as log:
self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop))
self.assertEqual(log.call_count, 1)
# format message
msg = log.call_args[0][0] % log.call_args[0][1:]
self.assertIn('Executing It Works!' * 10000
class HttpRequestHandler(aiohttp.server.ServerHttpProtocol):
async def handle_request(self, message, payload):
response = aiohttp.Response(
self.writer, 200, http_version=message.version
)
response.add_header('Content-Type', 'text/html')
response.add_header('Content-Length', str(len(PAYLOAD)))
response.send_headers()
response.write(PAYLOAD)
await response.write_eof()
asyncio.set_event_loop(self.loop)
f = self.loop.create_server(
lambda: HttpRequestHandler(keepalive_timeout=1),
'0.0.0.0', '0')
srv = self.loop.run_until_complete(f)
port = srv.sockets[0].getsockname()[1]
async def test():
for addr in (('localhost', port),
('127.0.0.1', port)):
async with aiohttp.ClientSession() as client:
async with client.get('http://{}:{}'.format(*addr)) as r:
self.assertEqual(r.status, 200)
self.assertEqual(len(await r.text()), len(PAYLOAD))
self.loop.run_until_complete(test())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
@unittest.skipIf(skip_tests, "no aiohttp module")
class Test_UV_AioHTTP(_TestAioHTTP, tb.UVTestCase):
pass
@unittest.skipIf(skip_tests, "no aiohttp module")
class Test_AIO_AioHTTP(_TestAioHTTP, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_executors.py 0000664 0003720 0003720 00000002041 13156036740 020504 0 ustar travis travis 0000000 0000000 import asyncio
import concurrent.futures
from uvloop import _testbase as tb
def fib(n):
if n < 2:
return 1
return fib(n - 2) + fib(n - 1)
class _TestExecutors:
def run_pool_test(self, pool_factory):
async def run():
pool = pool_factory()
with pool:
coros = []
for i in range(0, 10):
coros.append(self.loop.run_in_executor(pool, fib, i))
res = await asyncio.gather(*coros, loop=self.loop)
self.assertEqual(res, fib10)
await asyncio.sleep(0.01, loop=self.loop)
fib10 = [fib(i) for i in range(10)]
self.loop.run_until_complete(run())
def test_executors_process_pool_01(self):
self.run_pool_test(concurrent.futures.ProcessPoolExecutor)
def test_executors_process_pool_02(self):
self.run_pool_test(concurrent.futures.ThreadPoolExecutor)
class TestUVExecutors(_TestExecutors, tb.UVTestCase):
pass
class TestAIOExecutors(_TestExecutors, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/certs/ 0000775 0003720 0003720 00000000000 13156037661 016200 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/tests/certs/ssl_key.pem 0000664 0003720 0003720 00000001624 13156036740 020354 0 ustar travis travis 0000000 0000000 -----BEGIN PRIVATE KEY-----
MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBANtb0+YrKuxevGpm
LrjaUhZSgz6zFAmuGFmKmUbdjmfv9zSmmdsQIksK++jK0Be9LeZy20j6ahOfuVa0
ufEmPoP7Fy4hXegKZR9cCWcIe/A6H2xWF1IIJLRTLaU8ol/I7T+um5HD5AwAwNPP
USNU0Eegmvp+xxWu3NX2m1Veot85AgMBAAECgYA3ZdZ673X0oexFlq7AAmrutkHt
CL7LvwrpOiaBjhyTxTeSNWzvtQBkIU8DOI0bIazA4UreAFffwtvEuPmonDb3F+Iq
SMAu42XcGyVZEl+gHlTPU9XRX7nTOXVt+MlRRRxL6t9GkGfUAXI3XxJDXW3c0vBK
UL9xqD8cORXOfE06rQJBAP8mEX1ERkR64Ptsoe4281vjTlNfIbs7NMPkUnrn9N/Y
BLhjNIfQ3HFZG8BTMLfX7kCS9D593DW5tV4Z9BP/c6cCQQDcFzCcVArNh2JSywOQ
ZfTfRbJg/Z5Lt9Fkngv1meeGNPgIMLN8Sg679pAOOWmzdMO3V706rNPzSVMME7E5
oPIfAkEA8pDddarP5tCvTTgUpmTFbakm0KoTZm2+FzHcnA4jRh+XNTjTOv98Y6Ik
eO5d1ZnKXseWvkZncQgxfdnMqqpj5wJAcNq/RVne1DbYlwWchT2Si65MYmmJ8t+F
0mcsULqjOnEMwf5e+ptq5LzwbyrHZYq5FNk7ocufPv/ZQrcSSC+cFwJBAKvOJByS
x56qyGeZLOQlWS2JS3KJo59XuLFGqcbgN9Om9xFa41Yb4N9NvplFivsvZdw3m1Q/
SPIXQuT8RMPDVNQ=
-----END PRIVATE KEY-----
uvloop-0.8.1/tests/certs/ssl_cert.pem 0000664 0003720 0003720 00000001543 13156036740 020521 0 ustar travis travis 0000000 0000000 -----BEGIN CERTIFICATE-----
MIICVDCCAb2gAwIBAgIJANfHOBkZr8JOMA0GCSqGSIb3DQEBBQUAMF8xCzAJBgNV
BAYTAlhZMRcwFQYDVQQHEw5DYXN0bGUgQW50aHJheDEjMCEGA1UEChMaUHl0aG9u
IFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMDEw
MDgyMzAxNTZaFw0yMDEwMDUyMzAxNTZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQH
Ew5DYXN0bGUgQW50aHJheDEjMCEGA1UEChMaUHl0aG9uIFNvZnR3YXJlIEZvdW5k
YXRpb24xEjAQBgNVBAMTCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAw
gYkCgYEA21vT5isq7F68amYuuNpSFlKDPrMUCa4YWYqZRt2OZ+/3NKaZ2xAiSwr7
6MrQF70t5nLbSPpqE5+5VrS58SY+g/sXLiFd6AplH1wJZwh78DofbFYXUggktFMt
pTyiX8jtP66bkcPkDADA089RI1TQR6Ca+n7HFa7c1fabVV6i3zkCAwEAAaMYMBYw
FAYDVR0RBA0wC4IJbG9jYWxob3N0MA0GCSqGSIb3DQEBBQUAA4GBAHPctQBEQ4wd
BJ6+JcpIraopLn8BGhbjNWj40mmRqWB/NAWF6M5ne7KpGAu7tLeG4hb1zLaldK8G
lxy2GPSRF6LFS48dpEj2HbMv2nvv6xxalDMJ9+DicWgAKTQ6bcX2j3GUkCR0g/T1
CRlNBAAlvhKzO7Clpf9l0YKBEfraJByX
-----END CERTIFICATE-----
uvloop-0.8.1/tests/test_signals.py 0000664 0003720 0003720 00000016114 13156036740 020131 0 ustar travis travis 0000000 0000000 import asyncio
import signal
import subprocess
import sys
import time
from uvloop import _testbase as tb
DELAY = 0.1
class _TestSignal:
NEW_LOOP = None
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_stop(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
import time
from uvloop import _testbase as tb
async def worker():
print('READY', flush=True)
time.sleep(200)
@tb.silence_long_exec_warning()
def run():
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
finally:
loop.close()
run()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertIn(b'KeyboardInterrupt', err)
self.assertEqual(out, b'')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_continue(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
import time
from uvloop import _testbase as tb
async def worker():
print('READY', flush=True)
try:
time.sleep(200)
except KeyboardInterrupt:
print("oups")
await asyncio.sleep(0.5)
print('done')
@tb.silence_long_exec_warning()
def run():
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
finally:
loop.close()
run()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(out, b'oups\ndone\n')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_uvcode(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertIn(b'KeyboardInterrupt', err)
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_and_custom_handler(self):
async def runner():
PROG = R"""\
import asyncio
import signal
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
def handler_sig(say):
print(say, flush=True)
exit()
def handler_hup(say):
print(say, flush=True)
loop = """ + self.NEW_LOOP + """
loop.add_signal_handler(signal.SIGINT, handler_sig, '!s-int!')
loop.add_signal_handler(signal.SIGHUP, handler_hup, '!s-hup!')
asyncio.set_event_loop(loop)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGHUP)
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertIn(b'!s-hup!', out)
self.assertIn(b'!s-int!', out)
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_and_custom_handler_1(self):
async def runner():
PROG = R"""\
import asyncio
import signal
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
def handler1():
print("GOTIT", flush=True)
def handler2():
assert loop.remove_signal_handler(signal.SIGUSR1)
print("REMOVED", flush=True)
def handler_hup():
exit()
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.add_signal_handler(signal.SIGUSR1, handler1)
loop.add_signal_handler(signal.SIGUSR2, handler2)
loop.add_signal_handler(signal.SIGHUP, handler_hup)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR2)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGHUP)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(b'GOTIT\nGOTIT\nREMOVED\n', out)
self.loop.run_until_complete(runner())
def test_signals_invalid_signal(self):
with self.assertRaisesRegex(RuntimeError,
'sig {} cannot be caught'.format(
signal.SIGKILL)):
self.loop.add_signal_handler(signal.SIGKILL, lambda *a: None)
def test_signals_coro_callback(self):
async def coro(): pass
with self.assertRaisesRegex(TypeError, 'coroutines cannot be used'):
self.loop.add_signal_handler(signal.SIGHUP, coro)
class Test_UV_Signals(_TestSignal, tb.UVTestCase):
NEW_LOOP = 'uvloop.new_event_loop()'
class Test_AIO_Signals(_TestSignal, tb.AIOTestCase):
NEW_LOOP = 'asyncio.new_event_loop()'
uvloop-0.8.1/tests/test_udp.py 0000664 0003720 0003720 00000013576 13156036740 017272 0 ustar travis travis 0000000 0000000 import asyncio
import socket
import uvloop
import sys
from asyncio import test_utils
from uvloop import _testbase as tb
class MyDatagramProto(asyncio.DatagramProtocol):
done = None
def __init__(self, loop=None):
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'INITIALIZED'
def datagram_received(self, data, addr):
assert self.state == 'INITIALIZED', self.state
self.nbytes += len(data)
def error_received(self, exc):
assert self.state == 'INITIALIZED', self.state
raise exc
def connection_lost(self, exc):
assert self.state == 'INITIALIZED', self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestUDP:
def test_create_datagram_endpoint_addrs(self):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:' + data, addr)
for lc in (('127.0.0.1', 0), None):
if lc is None and not isinstance(self.loop, uvloop.Loop):
# TODO This looks like a bug in asyncio -- if no local_addr
# and no remote_addr are specified, the connection
# that asyncio creates is not bound anywhere.
return
with self.subTest(local_addr=lc):
coro = self.loop.create_datagram_endpoint(
TestMyDatagramProto, local_addr=lc, family=socket.AF_INET)
s_transport, server = self.loop.run_until_complete(coro)
host, port = s_transport.get_extra_info('sockname')
self.assertIsInstance(server, TestMyDatagramProto)
self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
extra = {}
if hasattr(socket, 'SO_REUSEPORT') and \
sys.version_info[:3] >= (3, 5, 1):
extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=socket.AF_INET,
remote_addr=None if lc is None else (host, port),
**extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx', (host, port) if lc is None else None)
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def test_create_datagram_endpoint_ipv6_family(self):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:' + data, addr)
coro = self.loop.create_datagram_endpoint(
TestMyDatagramProto, local_addr=None, family=socket.AF_INET6)
s_transport = None
try:
s_transport, server = self.loop.run_until_complete(coro)
finally:
if s_transport:
s_transport.close()
def test_create_datagram_endpoint_sock(self):
sock = None
local_address = ('127.0.0.1', 0)
infos = self.loop.run_until_complete(
self.loop.getaddrinfo(
*local_address, type=socket.SOCK_DGRAM))
for family, type, proto, cname, address in infos:
try:
sock = socket.socket(family=family, type=type, proto=proto)
sock.setblocking(False)
sock.bind(address)
except:
pass
else:
break
else:
assert False, 'Can not create socket.'
with sock:
try:
f = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop), sock=sock)
except TypeError as ex:
# asyncio in 3.5.0 doesn't have the 'sock' argument
if 'got an unexpected keyword argument' not in ex.args[0]:
raise
else:
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(pr, MyDatagramProto)
tr.close()
self.loop.run_until_complete(pr.done)
class Test_UV_UDP(_TestUDP, tb.UVTestCase):
def test_create_datagram_endpoint_wrong_sock(self):
sock = socket.socket(socket.AF_INET)
with sock:
coro = self.loop.create_datagram_endpoint(lambda: None, sock=sock)
with self.assertRaisesRegex(ValueError,
'A UDP Socket was expected'):
self.loop.run_until_complete(coro)
class Test_AIO_UDP(_TestUDP, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_pipes.py 0000664 0003720 0003720 00000017422 13156036740 017614 0 ustar travis travis 0000000 0000000 import asyncio
import io
import os
from asyncio import test_utils
from uvloop import _testbase as tb
# All tests are copied from asyncio (mostly as-is)
class MyReadPipeProto(asyncio.Protocol):
done = None
def __init__(self, loop=None):
self.state = ['INITIAL']
self.nbytes = 0
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == ['INITIAL'], self.state
self.state.append('CONNECTED')
def data_received(self, data):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.state.append('EOF')
def connection_lost(self, exc):
if 'EOF' not in self.state:
self.state.append('EOF') # It is okay if EOF is missed.
assert self.state == ['INITIAL', 'CONNECTED', 'EOF'], self.state
self.state.append('CLOSED')
if self.done:
self.done.set_result(None)
class MyWritePipeProto(asyncio.BaseProtocol):
done = None
def __init__(self, loop=None):
self.state = 'INITIAL'
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
def connection_lost(self, exc):
assert self.state == 'CONNECTED', self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _BasePipeTest:
def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(
lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
master_read_obj = io.open(master, 'rb', 0)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(lambda: proto,
master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(slave, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
os.write(slave, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
# On Linux, transport raises EIO when slave is closed --
# ignore it.
self.loop.set_exception_handler(lambda loop, ctx: None)
os.close(slave)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_write_pipe(self):
rpipe, wpipe = os.pipe()
os.set_blocking(rpipe, False)
pipeobj = io.open(wpipe, 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(rpipe, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(rpipe)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_write_pipe_disconnect_on_close(self):
rsock, wsock = test_utils.socketpair()
rsock.setblocking(False)
pipeobj = io.open(wsock.detach(), 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
self.assertEqual(b'1', data)
rsock.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_write_pty(self):
master, slave = os.openpty()
os.set_blocking(master, False)
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(master, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
class Test_UV_Pipes(_BasePipeTest, tb.UVTestCase):
pass
class Test_AIO_Pipes(_BasePipeTest, tb.AIOTestCase):
pass
uvloop-0.8.1/tests/test_cython.py 0000664 0003720 0003720 00000001675 13156036740 020003 0 ustar travis travis 0000000 0000000 import asyncio
from uvloop._testbase import UVTestCase
class TestCythonIntegration(UVTestCase):
def test_cython_coro_is_coroutine(self):
from uvloop.loop import _test_coroutine_1
from asyncio.coroutines import _format_coroutine
coro = _test_coroutine_1()
self.assertEqual(_format_coroutine(coro), '_test_coroutine_1()')
self.assertEqual(_test_coroutine_1.__qualname__, '_test_coroutine_1')
self.assertEqual(_test_coroutine_1.__name__, '_test_coroutine_1')
self.assertTrue(asyncio.iscoroutine(coro))
fut = asyncio.ensure_future(coro, loop=self.loop)
self.assertTrue(isinstance(fut, asyncio.Future))
self.assertTrue(isinstance(fut, asyncio.Task))
fut.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(fut)
_format_coroutine(coro) # This line checks against Cython segfault
coro.close()
uvloop-0.8.1/tests/__init__.py 0000664 0003720 0003720 00000000602 13156036740 017164 0 ustar travis travis 0000000 0000000 import os.path
import sys
import unittest
import unittest.runner
def suite():
test_loader = unittest.TestLoader()
test_suite = test_loader.discover(
os.path.dirname(__file__), pattern='test_*.py')
return test_suite
if __name__ == '__main__':
runner = unittest.runner.TextTestRunner()
result = runner.run(suite())
sys.exit(not result.wasSuccessful())
uvloop-0.8.1/tests/test_tcp.py 0000664 0003720 0003720 00000076641 13156036740 017272 0 ustar travis travis 0000000 0000000 import asyncio
import gc
import socket
import unittest.mock
import uvloop
import ssl
import sys
import threading
from uvloop import _testbase as tb
class MyBaseProto(asyncio.Protocol):
connected = None
done = None
def __init__(self, loop=None):
self.transport = None
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.connected = asyncio.Future(loop=loop)
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data):
assert self.state == 'CONNECTED', self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == 'CONNECTED', self.state
self.state = 'EOF'
def connection_lost(self, exc):
assert self.state in ('CONNECTED', 'EOF'), self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestTCP:
def test_create_server_1(self):
if self.is_asyncio_loop() and sys.version_info[:3] == (3, 5, 2):
# See https://github.com/python/asyncio/pull/366 for details.
raise unittest.SkipTest()
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'S', b'P'])
writer.write(bytearray(b'A'))
writer.write(memoryview(b'M'))
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
sock = socket.socket()
with sock:
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
await self.loop.sock_sendall(sock, A_DATA)
buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, B_DATA)
buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'SPAM')
async def start_server():
nonlocal CNT
CNT = 0
addrs = ('127.0.0.1', 'localhost')
if not isinstance(self.loop, uvloop.Loop):
# Hack to let tests run on Python 3.5.0
# (asyncio doesn't support multiple hosts in 3.5.0)
addrs = '127.0.0.1'
srv = await asyncio.start_server(
handle_client,
addrs, 0,
family=socket.AF_INET,
loop=self.loop)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
async def start_server_sock():
nonlocal CNT
CNT = 0
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
srv = await asyncio.start_server(
handle_client,
None, None,
family=socket.AF_INET,
loop=self.loop,
sock=sock)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
srv.close()
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
self.loop.run_until_complete(start_server_sock())
self.assertEqual(CNT, TOTAL_CNT)
def test_create_server_2(self):
with self.assertRaisesRegex(ValueError, 'nor sock were specified'):
self.loop.run_until_complete(self.loop.create_server(object))
def test_create_server_3(self):
''' check ephemeral port can be used '''
async def start_server_ephemeral_ports():
for port_sentinel in [0, None]:
srv = await self.loop.create_server(
asyncio.Protocol,
'127.0.0.1', port_sentinel,
family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
host, port = srv_socks[0].getsockname()
self.assertNotEqual(0, port)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
self.loop.run_until_complete(start_server_ephemeral_ports())
def test_create_server_4(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
with sock:
addr = sock.getsockname()
with self.assertRaisesRegex(OSError,
"error while attempting.*\('127.*: "
"address already in use"):
self.loop.run_until_complete(
self.loop.create_server(object, *addr))
def test_create_server_5(self):
# Test that create_server sets the TCP_IPV6ONLY flag,
# so it can bind to ipv4 and ipv6 addresses
# simultaneously.
port = tb.find_free_port()
async def runner():
srv = await self.loop.create_server(
asyncio.Protocol,
None, port)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(runner())
def test_create_server_6(self):
if not hasattr(socket, 'SO_REUSEPORT'):
raise unittest.SkipTest(
'The system does not support SO_REUSEPORT')
if sys.version_info[:3] < (3, 5, 1):
raise unittest.SkipTest(
'asyncio in CPython 3.5.0 does not have the '
'reuse_port argument')
port = tb.find_free_port()
async def runner():
srv1 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv2 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv1.close()
srv2.close()
await srv1.wait_closed()
await srv2.wait_closed()
self.loop.run_until_complete(runner())
def test_create_connection_1(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.write(b'OK')
data = yield tb.read(4)
self.assertEqual(data, b'BBBB')
yield tb.write(b'SPAM')
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
re = r'(a bytes-like object)|(must be byte-ish)'
with self.assertRaisesRegex(TypeError, re):
writer.write('AAAA')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
async def client_2(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
sock=sock,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
run(client_2)
def test_create_connection_2(self):
sock = socket.socket()
with sock:
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def client():
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
async def runner():
with self.assertRaises(ConnectionRefusedError):
await client()
self.loop.run_until_complete(runner())
def test_create_connection_3(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.close()
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
writer.close()
nonlocal CNT
CNT += 1
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
def test_create_connection_4(self):
sock = socket.socket()
sock.close()
async def client():
reader, writer = await asyncio.open_connection(
sock=sock,
loop=self.loop)
async def runner():
with self.assertRaisesRegex(OSError, 'Bad file'):
await client()
self.loop.run_until_complete(runner())
def test_transport_shutdown(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 100 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
self.assertEqual(data, b'AAAA')
writer.write(b'OK')
writer.write_eof()
writer.write_eof()
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
data = await reader.readexactly(2)
self.assertEqual(data, b'OK')
writer.close()
async def start_server():
nonlocal CNT
CNT = 0
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
def test_tcp_handle_exception_in_connection_made(self):
# Test that if connection_made raises an exception,
# 'create_connection' still returns.
# Silence error logging
self.loop.set_exception_handler(lambda *args: None)
fut = asyncio.Future(loop=self.loop)
connection_lost_called = asyncio.Future(loop=self.loop)
async def server(reader, writer):
try:
await reader.read()
finally:
writer.close()
class Proto(asyncio.Protocol):
def connection_made(self, tr):
1 / 0
def connection_lost(self, exc):
connection_lost_called.set_result(exc)
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
Proto, *srv.sockets[0].getsockname()),
timeout=1.0, loop=self.loop)
fut.set_result(None)
tr.close()
self.loop.run_until_complete(runner())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
self.loop.run_until_complete(fut)
self.assertIsNone(
self.loop.run_until_complete(connection_lost_called))
class Test_UV_TCP(_TestTCP, tb.UVTestCase):
def test_transport_get_extra_info(self):
# This tests is only for uvloop. asyncio should pass it
# too in Python 3.6.
fut = asyncio.Future(loop=self.loop)
async def handle_client(reader, writer):
with self.assertRaises(asyncio.IncompleteReadError):
data = await reader.readexactly(4)
writer.close()
# Previously, when we used socket.fromfd to create a socket
# for UVTransports (to make get_extra_info() work), a duplicate
# of the socket was created, preventing UVTransport from being
# properly closed.
# This test ensures that server handle will receive an EOF
# and finish the request.
fut.set_result(None)
async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
if hasattr(t, 'get_protocol'):
p2 = asyncio.Protocol()
self.assertIs(t.get_protocol(), p)
t.set_protocol(p2)
self.assertIs(t.get_protocol(), p2)
t.set_protocol(p)
self.assertFalse(t._paused)
t.pause_reading()
self.assertTrue(t._paused)
t.resume_reading()
self.assertFalse(t._paused)
sock = t.get_extra_info('socket')
self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_reader(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_reader(sock.fileno())
self.assertTrue(isinstance(sock, socket.socket))
self.assertEqual(t.get_extra_info('sockname'),
sockname)
self.assertEqual(t.get_extra_info('peername'),
peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'),
peername)
self.assertEqual(t.get_extra_info('sockname'),
sockname)
async def start_server():
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
addr = srv.sockets[0].getsockname()
await test_client(addr)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
def test_create_server_float_backlog(self):
# asyncio spits out a warning we cannot suppress
async def runner(bl):
await self.loop.create_server(
asyncio.Protocol,
None, 0, backlog=bl)
for bl in (1.1, '1'):
with self.subTest(backlog=bl):
with self.assertRaisesRegex(TypeError, 'integer'):
self.loop.run_until_complete(runner(bl))
def test_many_small_writes(self):
N = 10000
TOTAL = 0
fut = self.loop.create_future()
async def server(reader, writer):
nonlocal TOTAL
while True:
d = await reader.read(10000)
if not d:
break
TOTAL += len(d)
fut.set_result(True)
writer.close()
async def run():
srv = await asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
addr = srv.sockets[0].getsockname()
r, w = await asyncio.open_connection(*addr, loop=self.loop)
DATA = b'x' * 102400
# Test _StreamWriteContext with short sequences of writes
w.write(DATA)
await w.drain()
for _ in range(3):
w.write(DATA)
await w.drain()
for _ in range(10):
w.write(DATA)
await w.drain()
for _ in range(N):
w.write(DATA)
try:
w.write('a')
except TypeError:
pass
await w.drain()
for _ in range(N):
w.write(DATA)
await w.drain()
w.close()
await fut
srv.close()
await srv.wait_closed()
self.assertEqual(TOTAL, N * 2 * len(DATA) + 14 * len(DATA))
self.loop.run_until_complete(run())
def test_tcp_handle_unclosed_gc(self):
fut = self.loop.create_future()
async def server(reader, writer):
writer.transport.abort()
fut.set_result(True)
async def run():
addr = srv.sockets[0].getsockname()
await asyncio.open_connection(*addr, loop=self.loop)
await fut
srv.close()
await srv.wait_closed()
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop))
if self.loop.get_debug():
rx = r'unclosed resource '
def __call__(self, *args):
pass
def format_coroutine(qualname, state, src, source_traceback, generator=False):
if generator:
state = '%s' % state
else:
state = '%s, defined' % state
if source_traceback is not None:
frame = source_traceback[-1]
return ('coro=<%s() %s at %s> created at %s:%s'
% (qualname, state, src, frame[0], frame[1]))
else:
return 'coro=<%s() %s at %s>' % (qualname, state, src)
class _TestTasks:
def test_task_repr(self):
self.loop.set_debug(False)
@asyncio.coroutine
def notmuch():
yield from []
return 'abc'
# test coroutine function
self.assertEqual(notmuch.__name__, 'notmuch')
self.assertEqual(notmuch.__qualname__,
'_TestTasks.test_task_repr..notmuch')
self.assertEqual(notmuch.__module__, __name__)
filename, lineno = test_utils.get_function_source(notmuch)
src = "%s:%s" % (filename, lineno)
# test coroutine object
gen = notmuch()
coro_qualname = '_TestTasks.test_task_repr..notmuch'
self.assertEqual(gen.__name__, 'notmuch')
self.assertEqual(gen.__qualname__, coro_qualname)
# test pending Task
t = asyncio.Task(gen, loop=self.loop)
t.add_done_callback(Dummy())
coro = format_coroutine(coro_qualname, 'running', src,
t._source_traceback, generator=True)
self.assertEqual(repr(t),
'()]>' % coro)
# test canceling Task
t.cancel() # Does not take immediate effect!
self.assertEqual(repr(t),
'()]>' % coro)
# test canceled Task
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, t)
coro = format_coroutine(coro_qualname, 'done', src,
t._source_traceback)
self.assertEqual(repr(t),
'' % coro)
# test finished Task
t = asyncio.Task(notmuch(), loop=self.loop)
self.loop.run_until_complete(t)
coro = format_coroutine(coro_qualname, 'done', src,
t._source_traceback)
self.assertEqual(repr(t),
"" % coro)
def test_task_basics(self):
@asyncio.coroutine
def outer():
a = yield from inner1()
b = yield from inner2()
return a + b
@asyncio.coroutine
def inner1():
return 42
@asyncio.coroutine
def inner2():
return 1000
t = outer()
self.assertEqual(self.loop.run_until_complete(t), 1042)
def test_task_cancel_yield(self):
@asyncio.coroutine
def task():
while True:
yield
return 12
t = self.create_task(task())
test_utils.run_briefly(self.loop) # start coro
t.cancel()
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, t)
self.assertTrue(t.done())
self.assertTrue(t.cancelled())
self.assertFalse(t.cancel())
def test_task_cancel_inner_future(self):
f = self.create_future()
@asyncio.coroutine
def task():
yield from f
return 12
t = self.create_task(task())
test_utils.run_briefly(self.loop) # start task
f.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(t)
self.assertTrue(f.cancelled())
self.assertTrue(t.cancelled())
def test_task_cancel_both_task_and_inner_future(self):
f = self.create_future()
@asyncio.coroutine
def task():
yield from f
return 12
t = self.create_task(task())
self.assertEqual(asyncio.Task.all_tasks(loop=self.loop), {t})
test_utils.run_briefly(self.loop)
f.cancel()
t.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(t)
self.assertTrue(t.done())
self.assertTrue(f.cancelled())
self.assertTrue(t.cancelled())
def test_task_cancel_task_catching(self):
fut1 = self.create_future()
fut2 = self.create_future()
@asyncio.coroutine
def task():
yield from fut1
try:
yield from fut2
except asyncio.CancelledError:
return 42
t = self.create_task(task())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut1) # White-box test.
fut1.set_result(None)
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut2) # White-box test.
t.cancel()
self.assertTrue(fut2.cancelled())
res = self.loop.run_until_complete(t)
self.assertEqual(res, 42)
self.assertFalse(t.cancelled())
def test_task_cancel_task_ignoring(self):
fut1 = self.create_future()
fut2 = self.create_future()
fut3 = self.create_future()
@asyncio.coroutine
def task():
yield from fut1
try:
yield from fut2
except asyncio.CancelledError:
pass
res = yield from fut3
return res
t = self.create_task(task())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut1) # White-box test.
fut1.set_result(None)
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut2) # White-box test.
t.cancel()
self.assertTrue(fut2.cancelled())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut3) # White-box test.
fut3.set_result(42)
res = self.loop.run_until_complete(t)
self.assertEqual(res, 42)
self.assertFalse(fut3.cancelled())
self.assertFalse(t.cancelled())
def test_task_cancel_current_task(self):
@asyncio.coroutine
def task():
t.cancel()
self.assertTrue(t._must_cancel) # White-box test.
# The sleep should be canceled immediately.
yield from asyncio.sleep(100, loop=self.loop)
return 12
t = self.create_task(task())
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, t)
self.assertTrue(t.done())
self.assertFalse(t._must_cancel) # White-box test.
self.assertFalse(t.cancel())
def test_task_step_with_baseexception(self):
@asyncio.coroutine
def notmutch():
raise BaseException()
task = self.create_task(notmutch())
self.assertRaises(BaseException, task._step)
self.assertTrue(task.done())
self.assertIsInstance(task.exception(), BaseException)
def test_task_step_result_future(self):
# If coroutine returns future, task waits on this future.
class Fut(asyncio.Future):
def __init__(self, *args, **kwds):
self.cb_added = False
super().__init__(*args, **kwds)
def add_done_callback(self, fn):
self.cb_added = True
super().add_done_callback(fn)
fut = Fut(loop=self.loop)
result = None
@asyncio.coroutine
def wait_for_future():
nonlocal result
result = yield from fut
t = self.create_task(wait_for_future())
test_utils.run_briefly(self.loop)
self.assertTrue(fut.cb_added)
res = object()
fut.set_result(res)
test_utils.run_briefly(self.loop)
self.assertIs(res, result)
self.assertTrue(t.done())
self.assertIsNone(t.result())
def test_task_step_result(self):
@asyncio.coroutine
def notmuch():
yield None
yield 1
return 'ko'
self.assertRaises(
RuntimeError, self.loop.run_until_complete, notmuch())
def test_task_yield_vs_yield_from(self):
fut = asyncio.Future(loop=self.loop)
@asyncio.coroutine
def wait_for_future():
yield fut
task = wait_for_future()
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(task)
self.assertFalse(fut.done())
def test_task_current_task(self):
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
@asyncio.coroutine
def coro(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task)
task = self.create_task(coro(self.loop))
self.loop.run_until_complete(task)
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
def test_task_current_task_with_interleaving_tasks(self):
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
fut1 = self.create_future()
fut2 = self.create_future()
@asyncio.coroutine
def coro1(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task1)
yield from fut1
self.assertTrue(asyncio.Task.current_task(loop=loop) is task1)
fut2.set_result(True)
@asyncio.coroutine
def coro2(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task2)
fut1.set_result(True)
yield from fut2
self.assertTrue(asyncio.Task.current_task(loop=loop) is task2)
task1 = self.create_task(coro1(self.loop))
task2 = self.create_task(coro2(self.loop))
self.loop.run_until_complete(asyncio.wait((task1, task2),
loop=self.loop))
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
def test_task_yield_future_passes_cancel(self):
# Canceling outer() cancels inner() cancels waiter.
proof = 0
waiter = self.create_future()
@asyncio.coroutine
def inner():
nonlocal proof
try:
yield from waiter
except asyncio.CancelledError:
proof += 1
raise
else:
self.fail('got past sleep() in inner()')
@asyncio.coroutine
def outer():
nonlocal proof
try:
yield from inner()
except asyncio.CancelledError:
proof += 100 # Expect this path.
else:
proof += 10
f = asyncio.ensure_future(outer(), loop=self.loop)
test_utils.run_briefly(self.loop)
f.cancel()
self.loop.run_until_complete(f)
self.assertEqual(proof, 101)
self.assertTrue(waiter.cancelled())
def test_task_yield_wait_does_not_shield_cancel(self):
# Canceling outer() makes wait() return early, leaves inner()
# running.
proof = 0
waiter = self.create_future()
@asyncio.coroutine
def inner():
nonlocal proof
yield from waiter
proof += 1
@asyncio.coroutine
def outer():
nonlocal proof
d, p = yield from asyncio.wait([inner()], loop=self.loop)
proof += 100
f = asyncio.ensure_future(outer(), loop=self.loop)
test_utils.run_briefly(self.loop)
f.cancel()
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, f)
waiter.set_result(None)
test_utils.run_briefly(self.loop)
self.assertEqual(proof, 1)
###############################################################################
# Tests Matrix
###############################################################################
class Test_UV_UV_Tasks(_TestTasks, tb.UVTestCase):
def create_future(self):
return self.loop.create_future()
def create_task(self, coro):
return self.loop.create_task(coro)
class Test_UV_UV_Tasks_AIO_Future(_TestTasks, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return self.loop.create_task(coro)
class Test_UV_AIO_Tasks(_TestTasks, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return asyncio.Task(coro, loop=self.loop)
class Test_AIO_Tasks(_TestTasks, tb.AIOTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return asyncio.Task(coro, loop=self.loop)
uvloop-0.8.1/docs/ 0000775 0003720 0003720 00000000000 13156037661 014646 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/docs/user/ 0000775 0003720 0003720 00000000000 13156037661 015624 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/docs/user/index.rst 0000664 0003720 0003720 00000001317 13156036740 017464 0 ustar travis travis 0000000 0000000 User Guide
==========
This section of the documentation provides information about how to use
uvloop.
Installation
------------
`uvloop` is available from PyPI. It requires Python 3.5.
Use pip to install it.
.. code-block:: console
$ pip install uvloop
Using uvloop
------------
To make asyncio use the event loop provided by `uvloop`, you install the
`uvloop` event loop policy:
.. code-block:: python
import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
Alternatively, you can create an instance of the loop manually, using:
.. code-block:: python
import asyncio
import uvloop
loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
uvloop-0.8.1/docs/api/ 0000775 0003720 0003720 00000000000 13156037661 015417 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/docs/api/index.rst 0000664 0003720 0003720 00000000475 13156036740 017263 0 ustar travis travis 0000000 0000000 API
===
If you are looking for information on a specific function, class or method,
this part of the documentation is for you.
uvloop
------
.. autoclass:: uvloop.EventLoopPolicy
:members:
.. autofunction:: uvloop.new_event_loop
.. autoclass:: uvloop.Loop
:members:
:undoc-members:
:inherited-members:
uvloop-0.8.1/docs/conf.py 0000664 0003720 0003720 00000003736 13156036740 016153 0 ustar travis travis 0000000 0000000 #!/usr/bin/env python3
import alabaster
import os
import re
import sys
sys.path.insert(0, os.path.abspath('..'))
with open(os.path.abspath('../setup.py'), 'rt') as f:
_m = re.search(r'''VERSION\s*=\s*(?P'|")(?P[\d\.]+)(?P=q)''', f.read())
if not _m:
raise RuntimeError('unable to read the version from setup.py')
version = _m.group('ver')
# -- General configuration ------------------------------------------------
extensions = [
'sphinx.ext.autodoc',
'alabaster',
]
templates_path = ['_templates']
source_suffix = '.rst'
master_doc = 'index'
project = 'uvloop'
copyright = '2016-present, MagicStack, Inc'
author = 'Yury Selivanov'
release = version
language = None
exclude_patterns = ['_build']
pygments_style = 'sphinx'
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
html_theme = 'alabaster'
html_theme_options = {
'description': 'uvloop is an ultra fast implementation of the '
'asyncio event loop on top of libuv.',
'show_powered_by': False,
}
html_theme_path = [alabaster.get_path()]
html_title = 'uvloop Documentation'
html_short_title = 'uvloop'
html_static_path = []
html_sidebars = {
'**': [
'about.html',
'navigation.html',
]
}
html_show_sourcelink = False
html_show_sphinx = False
html_show_copyright = True
htmlhelp_basename = 'uvloopdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {}
latex_documents = [
(master_doc, 'uvloop.tex', 'uvloop Documentation',
'Yury Selivanov', 'manual'),
]
# -- Options for manual page output ---------------------------------------
man_pages = [
(master_doc, 'uvloop', 'uvloop Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
texinfo_documents = [
(master_doc, 'uvloop', 'uvloop Documentation',
author, 'uvloop', 'One line description of project.',
'Miscellaneous'),
]
uvloop-0.8.1/docs/index.rst 0000664 0003720 0003720 00000004176 13156036740 016514 0 ustar travis travis 0000000 0000000 .. image:: https://travis-ci.org/MagicStack/uvloop.svg?branch=master
:target: https://travis-ci.org/MagicStack/uvloop
.. image:: https://img.shields.io/pypi/status/uvloop.svg?maxAge=2592000?style=plastic
:target: https://pypi.python.org/pypi/uvloop
.. image:: https://img.shields.io/github/stars/magicstack/uvloop.svg?style=social&label=GitHub
:target: https://github.com/MagicStack/uvloop
uvloop
======
`uvloop` is a fast, drop-in replacement of the built-in asyncio event loop.
`uvloop` is released under the MIT license.
`uvloop` and asyncio, combined with the power of async/await in Python 3.5,
makes it easier than ever to write high-performance networking code in Python.
`uvloop` makes asyncio fast. In fact, it is at least 2x faster than nodejs,
gevent, as well as any other Python asynchronous framework. The performance of
uvloop-based asyncio is close to that of Go programs.
You can read more about uvloop in this
`blog post `_.
Architecture
------------
The asyncio module, introduced by PEP 3156, is a collection of network
transports, protocols, and streams abstractions, with a pluggable event loop.
The event loop is the heart of asyncio. It provides APIs for:
- scheduling calls,
- transmitting data over the network,
- performing DNS queries,
- handling OS signals,
- convenient abstractions to create servers and connections,
- working with subprocesses asynchronously.
`uvloop` implements the :class:`asyncio.AbstractEventLoop` interface which
means that it provides a drop-in replacement of the asyncio event loop.
`uvloop` is written in Cython and is built on top of libuv.
libuv is a high performance, multiplatform asynchronous I/O library used by
nodejs. Because of how wide-spread and popular nodejs is, libuv is fast and
stable.
`uvloop` implements all asyncio event loop APIs. High-level Python objects
wrap low-level libuv structs and functions. Inheritance is used to keep the
code DRY and ensure that any manual memory management is in sync with libuv
primitives' lifespans.
Contents
--------
.. toctree::
:maxdepth: 1
user/index
dev/index
uvloop-0.8.1/docs/dev/ 0000775 0003720 0003720 00000000000 13156037661 015424 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/docs/dev/index.rst 0000664 0003720 0003720 00000005410 13156036740 017262 0 ustar travis travis 0000000 0000000 Developers Guide
================
The project is hosted on `GitHub `_.
and uses `Travis `_ for
Continuous Integration.
A goal for the `uvloop` project is to provide a drop in replacement for the
`asyncio` event loop. Any deviation from the behavior of the reference
`asyncio` event loop is considered a bug.
If you have found a bug or have an idea for an enhancement that would
improve the library, use the
`bug tracker `_.
Get the source
--------------
.. code-block:: console
$ git clone --recursive git@github.com:MagicStack/uvloop.git
The ``--recursive`` argument is important. It will fetch the ``libuv`` source
from the `libuv` Github repository.
Build
-----
To build `uvloop`, you'll need ``Cython`` and Python 3.5.
.. note::
The best way to work on `uvloop` is to create a virtual env, so that
you'll have Cython and Python commands pointing to the correct
tools.
.. code-block:: console
$ python3 -m venv myvenv
$ cd myvenv
$ source bin/activate
$ cd ..
Install Cython if not already present.
.. code-block:: console
$ pip install Cython
Build `uvloop` by running the ``make`` rule from the top level directory.
.. code-block:: console
$ cd uvloop
$ make
Test
----
The easiest method to run all of the unit tests is to run the ``make test``
rule from the top level directory. This runs the standard library
``unittest`` tool which discovers all the unit tests and runs them.
It actually runs them twice, once with the `PYTHONASYNCIODEBUG` enabled and
once without.
.. code-block:: console
$ cd uvloop
$ make test
Individual Tests
++++++++++++++++
Individual unit tests can be run using the standard library ``unittest``
or ``pytest`` package.
The easiest approach to ensure that ``uvloop`` can be found by Python is to
install the package using ``pip``:
.. code-block:: console
$ cd uvloop
$ pip install -e .
You can then run the unit tests individually from the tests directory using
``unittest``:
.. code-block:: console
$ cd uvloop/tests
$ python -m unittest test_tcp
or using ``pytest``:
.. code-block:: console
$ cd uvloop/tests
$ py.test -k test_signals_sigint_uvcode
Documentation
-------------
To rebuild the project documentation, developers should run the ``make docs``
rule from the top level directory. It performs a number of steps to create
a new set of `sphinx `_ html content.
This step requires Sphinx to be installed. Sphinx can be installed using
pip:
.. code-block:: console
$ pip install sphinx
Once Sphinx is available you can make the documentation using:
.. code-block:: console
$ make docs
uvloop-0.8.1/uvloop/ 0000775 0003720 0003720 00000000000 13156037661 015242 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/uvloop/loop.pyx 0000664 0003720 0003720 00000257471 13156036740 016772 0 ustar travis travis 0000000 0000000 # cython: language_level=3, embedsignature=True
import asyncio
cimport cython
from .includes.debug cimport UVLOOP_DEBUG
from .includes cimport uv
from .includes cimport system
from .includes.python cimport PyMem_RawMalloc, PyMem_RawFree, \
PyMem_RawCalloc, PyMem_RawRealloc, \
PyUnicode_EncodeFSDefault, \
PyErr_SetInterrupt, \
PyOS_AfterFork, \
_PyImport_AcquireLock, \
_PyImport_ReleaseLock, \
_Py_RestoreSignals
from libc.stdint cimport uint64_t
from libc.string cimport memset, strerror, memcpy
from libc cimport errno
from cpython cimport PyObject
from cpython cimport PyErr_CheckSignals, PyErr_Occurred
from cpython cimport PyThread_get_thread_ident
from cpython cimport Py_INCREF, Py_DECREF, Py_XDECREF, Py_XINCREF
from cpython cimport PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, \
Py_buffer, PyBytes_AsString, PyBytes_CheckExact, \
Py_SIZE, PyBytes_AS_STRING
from cpython cimport PyErr_CheckSignals
from . import _noop
include "includes/consts.pxi"
include "includes/stdlib.pxi"
include "errors.pyx"
cdef _is_sock_stream(sock_type):
# Linux's socket.type is a bitmask that can include extra info
# about socket, therefore we can't do simple
# `sock_type == socket.SOCK_STREAM`.
return (sock_type & uv.SOCK_STREAM) == uv.SOCK_STREAM
cdef _is_sock_dgram(sock_type):
# Linux's socket.type is a bitmask that can include extra info
# about socket, therefore we can't do simple
# `sock_type == socket.SOCK_DGRAM`.
return (sock_type & uv.SOCK_DGRAM) == uv.SOCK_DGRAM
cdef isfuture(obj):
if aio_isfuture is None:
return isinstance(obj, aio_Future)
else:
return aio_isfuture(obj)
@cython.no_gc_clear
cdef class Loop:
def __cinit__(self):
cdef int err
# Install PyMem* memory allocators if they aren't installed yet.
__install_pymem()
# Install pthread_atfork handlers
__install_atfork()
self.uvloop = \
PyMem_RawMalloc(sizeof(uv.uv_loop_t))
if self.uvloop is NULL:
raise MemoryError()
self.slow_callback_duration = 0.1
self._closed = 0
self._debug = 0
self._thread_is_main = 0
self._thread_id = 0
self._running = 0
self._stopping = 0
self._transports = weakref_WeakValueDictionary()
self._timers = set()
self._polls = dict()
self._recv_buffer_in_use = 0
err = uv.uv_loop_init(self.uvloop)
if err < 0:
raise convert_error(err)
self.uvloop.data = self
self._init_debug_fields()
self.active_process_handler = None
self._last_error = None
self._task_factory = None
self._exception_handler = None
self._default_executor = None
self._queued_streams = set()
self._ready = col_deque()
self._ready_len = 0
self.handler_async = UVAsync.new(
self, self._on_wake, self)
self.handler_idle = UVIdle.new(
self,
new_MethodHandle(
self, "loop._on_idle", self._on_idle, self))
# Needed to call `UVStream._exec_write` for writes scheduled
# during `Protocol.data_received`.
self.handler_check__exec_writes = UVCheck.new(
self,
new_MethodHandle(
self, "loop._exec_queued_writes",
self._exec_queued_writes, self))
self._ssock = self._csock = None
self._signal_handlers = None
self._coroutine_wrapper_set = False
if hasattr(sys, 'get_asyncgen_hooks'):
# Python >= 3.6
# A weak set of all asynchronous generators that are
# being iterated by the loop.
self._asyncgens = weakref_WeakSet()
else:
self._asyncgens = None
# Set to True when `loop.shutdown_asyncgens` is called.
self._asyncgens_shutdown_called = False
def __init__(self):
self.set_debug((not sys_ignore_environment
and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
def __dealloc__(self):
if self._running == 1:
raise RuntimeError('deallocating a running event loop!')
if self._closed == 0:
aio_logger.error("deallocating an open event loop")
return
PyMem_RawFree(self.uvloop)
self.uvloop = NULL
cdef _init_debug_fields(self):
self._debug_cc = bool(UVLOOP_DEBUG)
if UVLOOP_DEBUG:
self._debug_handles_current = col_Counter()
self._debug_handles_closed = col_Counter()
self._debug_handles_total = col_Counter()
else:
self._debug_handles_current = None
self._debug_handles_closed = None
self._debug_handles_total = None
self._debug_uv_handles_total = 0
self._debug_uv_handles_freed = 0
self._debug_stream_read_cb_total = 0
self._debug_stream_read_eof_total = 0
self._debug_stream_read_errors_total = 0
self._debug_stream_read_cb_errors_total = 0
self._debug_stream_read_eof_cb_errors_total = 0
self._debug_stream_shutdown_errors_total = 0
self._debug_stream_listen_errors_total = 0
self._debug_stream_write_tries = 0
self._debug_stream_write_errors_total = 0
self._debug_stream_write_ctx_total = 0
self._debug_stream_write_ctx_cnt = 0
self._debug_stream_write_cb_errors_total = 0
self._debug_cb_handles_total = 0
self._debug_cb_handles_count = 0
self._debug_cb_timer_handles_total = 0
self._debug_cb_timer_handles_count = 0
self._poll_read_events_total = 0
self._poll_read_cb_errors_total = 0
self._poll_write_events_total = 0
self._poll_write_cb_errors_total = 0
self._sock_try_write_total = 0
self._debug_exception_handler_cnt = 0
cdef _setup_signals(self):
self._ssock, self._csock = socket_socketpair()
self._ssock.setblocking(False)
self._csock.setblocking(False)
try:
signal_set_wakeup_fd(self._csock.fileno())
except ValueError:
# Not the main thread
self._ssock.close()
self._csock.close()
self._ssock = self._csock = None
return
self._add_reader(
self._ssock.fileno(),
new_MethodHandle(
self,
"Loop._read_from_self",
self._read_from_self,
self))
self._signal_handlers = {}
cdef _shutdown_signals(self):
if self._signal_handlers is None:
return
for sig in list(self._signal_handlers):
self.remove_signal_handler(sig)
signal_set_wakeup_fd(-1)
self._remove_reader(self._ssock.fileno())
self._ssock.close()
self._csock.close()
cdef _read_from_self(self):
while True:
try:
data = self._ssock.recv(4096)
if not data:
break
self._process_self_data(data)
except InterruptedError:
continue
except BlockingIOError:
break
cdef _process_self_data(self, data):
for signum in data:
if not signum:
# ignore null bytes written by _write_to_self()
continue
self._handle_signal(signum)
cdef _handle_signal(self, sig):
cdef Handle handle
try:
handle = (self._signal_handlers[sig])
except KeyError:
handle = None
if handle is None:
# Some signal that we aren't listening through
# add_signal_handler. Invoke CPython eval loop
# to let it being processed.
PyErr_CheckSignals()
_noop.noop()
return
if handle.cancelled:
self.remove_signal_handler(sig) # Remove it properly.
else:
self._call_soon_handle(handle)
self.handler_async.send()
cdef _on_wake(self):
if (self._ready_len > 0 or self._stopping) \
and not self.handler_idle.running:
self.handler_idle.start()
cdef _on_idle(self):
cdef:
int i, ntodo
object popleft = self._ready.popleft
Handle handler
ntodo = len(self._ready)
if self._debug:
for i from 0 <= i < ntodo:
handler = popleft()
if handler.cancelled == 0:
try:
started = time_monotonic()
handler._run()
except BaseException as ex:
self._stop(ex)
return
else:
delta = time_monotonic() - started
if delta > self.slow_callback_duration:
aio_logger.warning(
'Executing %r took %.3f seconds',
handler, delta)
else:
for i from 0 <= i < ntodo:
handler = popleft()
if handler.cancelled == 0:
try:
handler._run()
except BaseException as ex:
self._stop(ex)
return
if len(self._queued_streams):
self._exec_queued_writes()
self._ready_len = len(self._ready)
if self._ready_len == 0 and self.handler_idle.running:
self.handler_idle.stop()
if self._stopping:
uv.uv_stop(self.uvloop) # void
cdef _stop(self, exc):
if exc is not None:
self._last_error = exc
if self._stopping == 1:
return
self._stopping = 1
if not self.handler_idle.running:
self.handler_idle.start()
cdef __run(self, uv.uv_run_mode mode):
# Although every UVHandle holds a reference to the loop,
# we want to do everything to ensure that the loop will
# never deallocate during the run -- so we do some
# manual refs management.
Py_INCREF(self)
with nogil:
err = uv.uv_run(self.uvloop, mode)
Py_DECREF(self)
if err < 0:
raise convert_error(err)
cdef _run(self, uv.uv_run_mode mode):
cdef int err
if self._closed == 1:
raise RuntimeError('unable to start the loop; it was closed')
if self._running == 1:
raise RuntimeError('this event loop is already running.')
if (aio_get_running_loop is not None and
aio_get_running_loop() is not None):
raise RuntimeError(
'Cannot run the event loop while another loop is running')
if self._signal_handlers is None:
self._setup_signals()
# reset _last_error
self._last_error = None
self._thread_id = PyThread_get_thread_ident()
self._thread_is_main = MAIN_THREAD_ID == self._thread_id
self._running = 1
self.handler_check__exec_writes.start()
self.handler_idle.start()
if aio_set_running_loop is not None:
aio_set_running_loop(self)
try:
self.__run(mode)
finally:
if aio_set_running_loop is not None:
aio_set_running_loop(None)
self.handler_check__exec_writes.stop()
self.handler_idle.stop()
self._thread_is_main = 0
self._thread_id = 0
self._running = 0
self._stopping = 0
if self._last_error is not None:
# The loop was stopped with an error with 'loop._stop(error)' call
raise self._last_error
cdef _close(self):
cdef int err
if self._running == 1:
raise RuntimeError("Cannot close a running event loop")
if self._closed == 1:
return
self._closed = 1
for cb_handle in self._ready:
cb_handle.cancel()
self._ready.clear()
self._ready_len = 0
if self._polls:
for poll_handle in self._polls.values():
(poll_handle)._close()
self._polls.clear()
if self._timers:
for timer_cbhandle in tuple(self._timers):
timer_cbhandle.cancel()
# Close all remaining handles
self.handler_async._close()
self.handler_idle._close()
self.handler_check__exec_writes._close()
__close_all_handles(self)
self._shutdown_signals()
# During this run there should be no open handles,
# so it should finish right away
self.__run(uv.UV_RUN_DEFAULT)
if self._timers:
raise RuntimeError(
"new timers were queued during loop closing: {}"
.format(self._timers))
if self._polls:
raise RuntimeError(
"new poll handles were queued during loop closing: {}"
.format(self._polls))
if self._ready:
raise RuntimeError(
"new callbacks were queued during loop closing: {}"
.format(self._ready))
err = uv.uv_loop_close(self.uvloop)
if err < 0:
raise convert_error(err)
self.handler_async = None
self.handler_idle = None
self.handler_check__exec_writes = None
executor = self._default_executor
if executor is not None:
self._default_executor = None
executor.shutdown(wait=False)
cdef uint64_t _time(self):
# asyncio doesn't have a time cache, neither should uvloop.
uv.uv_update_time(self.uvloop) # void
return uv.uv_now(self.uvloop)
cdef inline _queue_write(self, UVStream stream):
self._queued_streams.add(stream)
if not self.handler_check__exec_writes.running:
self.handler_check__exec_writes.start()
cdef _exec_queued_writes(self):
if len(self._queued_streams) == 0:
if self.handler_check__exec_writes.running:
self.handler_check__exec_writes.stop()
return
cdef:
UVStream stream
int queued_len
if UVLOOP_DEBUG:
queued_len = len(self._queued_streams)
for pystream in self._queued_streams:
stream = pystream
stream._exec_write()
if UVLOOP_DEBUG:
if len(self._queued_streams) != queued_len:
raise RuntimeError(
'loop._queued_streams are not empty after '
'_exec_queued_writes')
self._queued_streams.clear()
if self.handler_check__exec_writes.running:
self.handler_check__exec_writes.stop()
cdef inline _call_soon(self, object callback, object args):
cdef Handle handle
handle = new_Handle(self, callback, args)
self._call_soon_handle(handle)
return handle
cdef inline _call_soon_handle(self, Handle handle):
self._check_closed()
self._ready.append(handle)
self._ready_len += 1;
if not self.handler_idle.running:
self.handler_idle.start()
cdef _call_later(self, uint64_t delay, object callback, object args):
return TimerHandle(self, callback, args, delay)
cdef void _handle_exception(self, object ex):
if isinstance(ex, Exception):
self.call_exception_handler({'exception': ex})
else:
# BaseException
self._last_error = ex
# Exit ASAP
self._stop(None)
cdef inline _check_signal(self, sig):
if not isinstance(sig, int):
raise TypeError('sig must be an int, not {!r}'.format(sig))
if not (1 <= sig < signal_NSIG):
raise ValueError(
'sig {} out of range(1, {})'.format(sig, signal_NSIG))
cdef inline _check_closed(self):
if self._closed == 1:
raise RuntimeError('Event loop is closed')
cdef inline _check_thread(self):
if self._thread_id == 0:
return
cdef long thread_id = PyThread_get_thread_ident()
if thread_id != self._thread_id:
raise RuntimeError(
"Non-thread-safe operation invoked on an event loop other "
"than the current one")
cdef inline _new_future(self):
return future_factory(loop=self)
cdef _track_transport(self, UVBaseTransport transport):
self._transports[transport._fileno()] = transport
cdef _ensure_fd_no_transport(self, fd):
cdef UVBaseTransport tr
try:
tr = (self._transports[fd])
except KeyError:
pass
else:
if tr._is_alive():
raise RuntimeError(
'File descriptor {!r} is used by transport {!r}'.format(
fd, tr))
cdef inline _add_reader(self, fd, Handle handle):
cdef:
UVPoll poll
self._check_closed()
try:
poll = (self._polls[fd])
except KeyError:
poll = UVPoll.new(self, fd)
self._polls[fd] = poll
poll.start_reading(handle)
cdef inline _remove_reader(self, fd):
cdef:
UVPoll poll
if self._closed == 1:
return False
try:
poll = (self._polls[fd])
except KeyError:
return False
result = poll.stop_reading()
if not poll.is_active():
del self._polls[fd]
poll._close()
return result
cdef inline _add_writer(self, fd, Handle handle):
cdef:
UVPoll poll
self._check_closed()
try:
poll = (self._polls[fd])
except KeyError:
poll = UVPoll.new(self, fd)
self._polls[fd] = poll
poll.start_writing(handle)
cdef inline _remove_writer(self, fd):
cdef:
UVPoll poll
if self._closed == 1:
return False
try:
poll = (self._polls[fd])
except KeyError:
return False
result = poll.stop_writing()
if not poll.is_active():
del self._polls[fd]
poll._close()
return result
cdef _getaddrinfo(self, object host, object port,
int family, int type,
int proto, int flags,
int unpack):
if isinstance(port, str):
port = port.encode()
elif isinstance(port, int):
port = str(port).encode()
if port is not None and not isinstance(port, bytes):
raise TypeError('port must be a str, bytes or int')
if isinstance(host, str):
host = host.encode('idna')
if host is not None:
if not isinstance(host, bytes):
raise TypeError('host must be a str or bytes')
fut = self._new_future()
def callback(result):
if AddrInfo.isinstance(result):
try:
if unpack == 0:
data = result
else:
data = (result).unpack()
except Exception as ex:
if not fut.cancelled():
fut.set_exception(ex)
else:
if not fut.cancelled():
fut.set_result(data)
else:
if not fut.cancelled():
fut.set_exception(result)
AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
return fut
cdef _getnameinfo(self, system.sockaddr *addr, int flags):
cdef NameInfoRequest nr
fut = self._new_future()
def callback(result):
if isinstance(result, tuple):
fut.set_result(result)
else:
fut.set_exception(result)
nr = NameInfoRequest(self, callback)
nr.query(addr, flags)
return fut
cdef _sock_recv(self, fut, sock, n):
cdef:
Handle handle
int fd
fd = sock.fileno()
if fut.cancelled():
self._remove_reader(fd)
return
try:
data = sock.recv(n)
except (BlockingIOError, InterruptedError):
# No need to re-add the reader, let's just wait until
# the poll handler calls this callback again.
pass
except Exception as exc:
fut.set_exception(exc)
self._remove_reader(fd)
else:
fut.set_result(data)
self._remove_reader(fd)
cdef _sock_sendall(self, fut, sock, data):
cdef:
Handle handle
int n
int fd
fd = sock.fileno()
if fut.cancelled():
self._remove_writer(fd)
return
try:
n = sock.send(data)
except (BlockingIOError, InterruptedError):
# Try next time.
return
except Exception as exc:
fut.set_exception(exc)
self._remove_writer(fd)
return
if n == len(data):
fut.set_result(None)
self._remove_writer(fd)
else:
if n:
if not isinstance(data, memoryview):
data = memoryview(data)
data = data[n:]
handle = new_MethodHandle3(
self,
"Loop._sock_sendall",
self._sock_sendall,
self,
fut, sock, data)
self._add_writer(fd, handle)
cdef _sock_accept(self, fut, sock):
cdef:
Handle handle
fd = sock.fileno()
if fut.cancelled():
self._remove_reader(fd)
return
try:
conn, address = sock.accept()
conn.setblocking(False)
except (BlockingIOError, InterruptedError):
# There is an active reader for _sock_accept, so
# do nothing, it will be called again.
pass
except Exception as exc:
fut.set_exception(exc)
self._remove_reader(fd)
else:
fut.set_result((conn, address))
self._remove_reader(fd)
cdef _sock_connect(self, fut, sock, address):
cdef:
Handle handle
fd = sock.fileno()
try:
sock.connect(address)
except (BlockingIOError, InterruptedError):
# Issue #23618: When the C function connect() fails with EINTR, the
# connection runs in background. We have to wait until the socket
# becomes writable to be notified when the connection succeed or
# fails.
fut.add_done_callback(lambda fut: self._remove_writer(fd))
handle = new_MethodHandle3(
self,
"Loop._sock_connect",
self._sock_connect_cb,
self,
fut, sock, address)
self._add_writer(fd, handle)
except Exception as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
cdef _sock_connect_cb(self, fut, sock, address):
if fut.cancelled():
return
try:
err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
if err != 0:
# Jump to any except clause below.
raise OSError(err, 'Connect call failed %s' % (address,))
except (BlockingIOError, InterruptedError):
# socket is still registered, the callback will be retried later
pass
except Exception as exc:
fut.set_exception(exc)
else:
fut.set_result(None)
cdef _sock_set_reuseport(self, int fd):
cdef:
int err
int reuseport_flag = 1
err = system.setsockopt(
fd,
uv.SOL_SOCKET,
SO_REUSEPORT,
&reuseport_flag,
sizeof(reuseport_flag))
if err < 0:
raise convert_error(-errno.errno)
cdef _set_coroutine_wrapper(self, bint enabled):
enabled = bool(enabled)
if self._coroutine_wrapper_set == enabled:
return
wrapper = aio_debug_wrapper
current_wrapper = sys_get_coroutine_wrapper()
if enabled:
if current_wrapper not in (None, wrapper):
warnings.warn(
"loop.set_debug(True): cannot set debug coroutine "
"wrapper; another wrapper is already set %r" %
current_wrapper, RuntimeWarning)
else:
sys_set_coroutine_wrapper(wrapper)
self._coroutine_wrapper_set = True
else:
if current_wrapper not in (None, wrapper):
warnings.warn(
"loop.set_debug(False): cannot unset debug coroutine "
"wrapper; another wrapper was set %r" %
current_wrapper, RuntimeWarning)
else:
sys_set_coroutine_wrapper(None)
self._coroutine_wrapper_set = False
cdef _create_server(self, system.sockaddr *addr,
object protocol_factory,
Server server,
object ssl,
bint reuse_port,
object backlog):
cdef:
TCPServer tcp
int bind_flags
tcp = TCPServer.new(self, protocol_factory, server, ssl,
addr.sa_family)
if reuse_port:
self._sock_set_reuseport(tcp._fileno())
if addr.sa_family == uv.AF_INET6:
# Disable IPv4/IPv6 dual stack support (enabled by
# default on Linux) which makes a single socket
# listen on both address families.
bind_flags = uv.UV_TCP_IPV6ONLY
else:
bind_flags = 0
try:
tcp.bind(addr, bind_flags)
tcp.listen(backlog)
except OSError as err:
pyaddr = __convert_sockaddr_to_pyaddr(addr)
tcp._close()
raise OSError(err.errno, 'error while attempting '
'to bind on address %r: %s'
% (pyaddr, err.strerror.lower()))
except:
tcp._close()
raise
return tcp
def _get_backend_id(self):
"""This method is used by uvloop tests and is not part of the API."""
return uv.uv_backend_fd(self.uvloop)
def print_debug_info(self):
cdef:
int err
uv.uv_rusage_t rusage
if not UVLOOP_DEBUG:
raise NotImplementedError
err = uv.uv_getrusage(&rusage)
if err < 0:
raise convert_error(err)
################### OS
print('---- Process info: -----')
print('Process memory: {}'.format(rusage.ru_maxrss))
print('Number of signals: {}'.format(rusage.ru_nsignals))
print('')
################### Loop
print('--- Loop debug info: ---')
print('Loop time: {}'.format(self.time()))
print('Errors logged: {}'.format(
self._debug_exception_handler_cnt))
print()
print('Callback handles: {: <8} | {}'.format(
self._debug_cb_handles_count,
self._debug_cb_handles_total))
print('Timer handles: {: <8} | {}'.format(
self._debug_cb_timer_handles_count,
self._debug_cb_timer_handles_total))
print()
print(' alive | closed |')
print('UVHandles python | libuv | total')
print(' objs | handles |')
print('-------------------------------+---------+---------')
for name in sorted(self._debug_handles_total):
print(' {: <18} {: >7} | {: >7} | {: >7}'.format(
name,
self._debug_handles_current[name],
self._debug_handles_closed[name],
self._debug_handles_total[name]))
print()
print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
self._debug_uv_handles_total - self._debug_uv_handles_freed,
self._debug_uv_handles_freed,
self._debug_uv_handles_total))
print()
print('--- Streams debug info: ---')
print('Write errors: {}'.format(
self._debug_stream_write_errors_total))
print('Write without poll: {}'.format(
self._debug_stream_write_tries))
print('Write contexts: {: <8} | {}'.format(
self._debug_stream_write_ctx_cnt,
self._debug_stream_write_ctx_total))
print('Write failed callbacks: {}'.format(
self._debug_stream_write_cb_errors_total))
print()
print('Read errors: {}'.format(
self._debug_stream_read_errors_total))
print('Read callbacks: {}'.format(
self._debug_stream_read_cb_total))
print('Read failed callbacks: {}'.format(
self._debug_stream_read_cb_errors_total))
print('Read EOFs: {}'.format(
self._debug_stream_read_eof_total))
print('Read EOF failed callbacks: {}'.format(
self._debug_stream_read_eof_cb_errors_total))
print()
print('Listen errors: {}'.format(
self._debug_stream_listen_errors_total))
print('Shutdown errors {}'.format(
self._debug_stream_shutdown_errors_total))
print()
print('--- Polls debug info: ---')
print('Read events: {}'.format(
self._poll_read_events_total))
print('Read callbacks failed: {}'.format(
self._poll_read_cb_errors_total))
print('Write events: {}'.format(
self._poll_write_events_total))
print('Write callbacks failed: {}'.format(
self._poll_write_cb_errors_total))
print()
print('--- Sock ops successfull on 1st try: ---')
print('Socket try-writes: {}'.format(
self._sock_try_write_total))
print(flush=True)
# Public API
def __repr__(self):
return '<{}.{} running={} closed={} debug={}>'.format(
self.__class__.__module__,
self.__class__.__name__,
self.is_running(),
self.is_closed(),
self.get_debug())
def call_soon(self, callback, *args):
"""Arrange for a callback to be called as soon as possible.
This operates as a FIFO queue: callbacks are called in the
order in which they are registered. Each callback will be
called exactly once.
Any positional arguments after the callback will be passed to
the callback when it is called.
"""
if self._debug == 1:
self._check_thread()
if args:
return self._call_soon(callback, args)
else:
return self._call_soon(callback, None)
def call_soon_threadsafe(self, callback, *args):
"""Like call_soon(), but thread-safe."""
if not args:
args = None
handle = self._call_soon(callback, args)
self.handler_async.send()
return handle
def call_later(self, delay, callback, *args):
"""Arrange for a callback to be called at a given time.
Return a Handle: an opaque object with a cancel() method that
can be used to cancel the call.
The delay can be an int or float, expressed in seconds. It is
always relative to the current time.
Each callback will be called exactly once. If two callbacks
are scheduled for exactly the same time, it undefined which
will be called first.
Any positional arguments after the callback will be passed to
the callback when it is called.
"""
self._check_closed()
if self._debug == 1:
self._check_thread()
if delay < 0:
delay = 0
cdef uint64_t when = (delay * 1000)
if not args:
args = None
if when == 0:
return self._call_soon(callback, args)
else:
return self._call_later(when, callback, args)
def call_at(self, when, callback, *args):
"""Like call_later(), but uses an absolute time.
Absolute time corresponds to the event loop's time() method.
"""
return self.call_later(when - self.time(), callback, *args)
def time(self):
"""Return the time according to the event loop's clock.
This is a float expressed in seconds since an epoch, but the
epoch, precision, accuracy and drift are unspecified and may
differ per event loop.
"""
return self._time() / 1000
def stop(self):
"""Stop running the event loop.
Every callback already scheduled will still run. This simply informs
run_forever to stop looping after a complete iteration.
"""
self._call_soon_handle(
new_MethodHandle1(
self,
"Loop._stop",
self._stop,
self,
None))
def run_forever(self):
"""Run the event loop until stop() is called."""
self._check_closed()
mode = uv.UV_RUN_DEFAULT
if self._stopping:
# loop.stop() was called right before loop.run_forever().
# This is how asyncio loop behaves.
mode = uv.UV_RUN_NOWAIT
self._set_coroutine_wrapper(self._debug)
if self._asyncgens is not None:
old_agen_hooks = sys.get_asyncgen_hooks()
sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
finalizer=self._asyncgen_finalizer_hook)
try:
self._run(mode)
finally:
self._set_coroutine_wrapper(False)
if self._asyncgens is not None:
sys.set_asyncgen_hooks(*old_agen_hooks)
def close(self):
"""Close the event loop.
The event loop must not be running.
This is idempotent and irreversible.
No other methods should be called after this one.
"""
self._close()
def get_debug(self):
return bool(self._debug)
def set_debug(self, enabled):
self._debug = bool(enabled)
if self.is_running():
self._set_coroutine_wrapper(self._debug)
def is_running(self):
"""Return whether the event loop is currently running."""
return bool(self._running)
def is_closed(self):
"""Returns True if the event loop was closed."""
return bool(self._closed)
def create_future(self):
"""Create a Future object attached to the loop."""
return self._new_future()
def create_task(self, coro):
"""Schedule a coroutine object.
Return a task object.
"""
self._check_closed()
if self._task_factory is None:
task = task_factory(coro, loop=self)
else:
task = self._task_factory(self, coro)
return task
def set_task_factory(self, factory):
"""Set a task factory that will be used by loop.create_task().
If factory is None the default task factory will be set.
If factory is a callable, it should have a signature matching
'(loop, coro)', where 'loop' will be a reference to the active
event loop, 'coro' will be a coroutine object. The callable
must return a Future.
"""
if factory is not None and not callable(factory):
raise TypeError('task factory must be a callable or None')
self._task_factory = factory
def get_task_factory(self):
"""Return a task factory, or None if the default one is in use."""
return self._task_factory
def run_until_complete(self, future):
"""Run until the Future is done.
If the argument is a coroutine, it is wrapped in a Task.
WARNING: It would be disastrous to call run_until_complete()
with the same coroutine twice -- it would wrap it in two
different Tasks and that can't be good.
Return the Future's result, or raise its exception.
"""
self._check_closed()
new_task = not isfuture(future)
future = aio_ensure_future(future, loop=self)
if new_task:
# An exception is raised if the future didn't complete, so there
# is no need to log the "destroy pending task" message
future._log_destroy_pending = False
done_cb = lambda fut: self.stop()
future.add_done_callback(done_cb)
try:
self.run_forever()
except:
if new_task and future.done() and not future.cancelled():
# The coroutine raised a BaseException. Consume the exception
# to not log a warning, the caller doesn't have access to the
# local task.
future.exception()
raise
future.remove_done_callback(done_cb)
if not future.done():
raise RuntimeError('Event loop stopped before Future completed.')
return future.result()
def getaddrinfo(self, object host, object port, *,
int family=0, int type=0, int proto=0, int flags=0):
addr = __static_getaddrinfo_pyaddr(host, port, family,
type, proto, flags)
if addr is not None:
fut = self._new_future()
fut.set_result([addr])
return fut
return self._getaddrinfo(host, port, family, type, proto, flags, 1)
async def getnameinfo(self, sockaddr, int flags=0):
cdef:
AddrInfo ai_cnt
system.addrinfo *ai
system.sockaddr_in6 *sin6
if not isinstance(sockaddr, tuple):
raise TypeError('getnameinfo() argument 1 must be a tuple')
sl = len(sockaddr)
if sl < 2 or sl > 4:
raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
if sl > 2:
flowinfo = sockaddr[2]
if flowinfo < 0 or flowinfo > 0xfffff:
raise OverflowError(
'getsockaddrarg: flowinfo must be 0-1048575.')
else:
flowinfo = 0
if sl > 3:
scope_id = sockaddr[3]
if scope_id < 0 or scope_id > 2 ** 32:
raise OverflowError(
'getsockaddrarg: scope_id must be unsigned 32 bit integer')
else:
scope_id = 0
ai_cnt = await self._getaddrinfo(
sockaddr[0], sockaddr[1],
uv.AF_UNSPEC, # family
uv.SOCK_DGRAM, # type
0, # proto
uv.AI_NUMERICHOST, # flags
0) # unpack
ai = ai_cnt.data
if ai.ai_next:
raise OSError("sockaddr resolved to multiple addresses")
if ai.ai_family == uv.AF_INET:
if sl > 2:
raise OSError("IPv4 sockaddr must be 2 tuple")
elif ai.ai_family == uv.AF_INET6:
# Modify some fields in `ai`
sin6 = ai.ai_addr
sin6.sin6_flowinfo = system.htonl(flowinfo)
sin6.sin6_scope_id = scope_id
return await self._getnameinfo(ai.ai_addr, flags)
async def create_server(self, protocol_factory, host=None, port=None,
*,
int family=uv.AF_UNSPEC,
int flags=uv.AI_PASSIVE,
sock=None,
backlog=100,
ssl=None,
reuse_address=None, # ignored, libuv sets it
reuse_port=None):
"""A coroutine which creates a TCP server bound to host and port.
The return value is a Server object which can be used to stop
the service.
If host is an empty string or None all interfaces are assumed
and a list of multiple sockets will be returned (most likely
one for IPv4 and another one for IPv6). The host parameter can also be a
sequence (e.g. list) of hosts to bind to.
family can be set to either AF_INET or AF_INET6 to force the
socket to use IPv4 or IPv6. If not set it will be determined
from host (defaults to AF_UNSPEC).
flags is a bitmask for getaddrinfo().
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows.
"""
cdef:
TCPServer tcp
system.addrinfo *addrinfo
Server server
if sock is not None and sock.family == uv.AF_UNIX:
if host is not None or port is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
return await self.create_unix_server(
protocol_factory, sock=sock, ssl=ssl)
server = Server(self)
if ssl is not None and not isinstance(ssl, ssl_SSLContext):
raise TypeError('ssl argument must be an SSLContext or None')
if host is not None or port is not None:
if sock is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
reuse_port = bool(reuse_port)
if reuse_port and not has_SO_REUSEPORT:
raise ValueError(
'reuse_port not supported by socket module')
if host == '':
hosts = [None]
elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
hosts = [host]
else:
hosts = host
fs = [self._getaddrinfo(host, port, family,
uv.SOCK_STREAM, 0, flags,
0) for host in hosts]
infos = await aio_gather(*fs, loop=self)
completed = False
try:
for info in infos:
addrinfo = (info).data
while addrinfo != NULL:
if addrinfo.ai_family == uv.AF_UNSPEC:
raise RuntimeError('AF_UNSPEC in DNS results')
tcp = self._create_server(
addrinfo.ai_addr, protocol_factory, server,
ssl, reuse_port, backlog)
server._add_server(tcp)
addrinfo = addrinfo.ai_next
completed = True
finally:
if not completed:
server.close()
else:
if sock is None:
raise ValueError('Neither host/port nor sock were specified')
if not _is_sock_stream(sock.type):
raise ValueError(
'A Stream Socket was expected, got {!r}'.format(sock))
tcp = TCPServer.new(self, protocol_factory, server, ssl,
uv.AF_UNSPEC)
# See a comment on os_dup in create_connection
fileno = os_dup(sock.fileno())
try:
tcp._open(fileno)
tcp._attach_fileobj(sock)
tcp.listen(backlog)
except:
tcp._close()
raise
server._add_server(tcp)
return server
async def create_connection(self, protocol_factory, host=None, port=None, *,
ssl=None, family=0, proto=0, flags=0, sock=None,
local_addr=None, server_hostname=None):
"""Connect to a TCP server.
Create a streaming transport connection to a given Internet host and
port: socket family AF_INET or socket.AF_INET6 depending on host (or
family if specified), socket type SOCK_STREAM. protocol_factory must be
a callable returning a protocol instance.
This method is a coroutine which will try to establish the connection
in the background. When successful, the coroutine returns a
(transport, protocol) pair.
"""
cdef:
AddrInfo ai_local = None
AddrInfo ai_remote
TCPTransport tr
system.addrinfo *rai = NULL
system.addrinfo *lai = NULL
system.addrinfo *rai_iter = NULL
system.addrinfo *lai_iter = NULL
system.addrinfo rai_static
system.sockaddr_storage rai_addr_static
system.addrinfo lai_static
system.sockaddr_storage lai_addr_static
object app_protocol
object protocol
object ssl_waiter
if sock is not None and sock.family == uv.AF_UNIX:
if host is not None or port is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
return await self.create_unix_connection(
protocol_factory, None,
sock=sock, ssl=ssl, server_hostname=server_hostname)
app_protocol = protocol = protocol_factory()
ssl_waiter = None
if ssl:
if server_hostname is None:
if not host:
raise ValueError('You must set server_hostname '
'when using ssl without a host')
server_hostname = host
ssl_waiter = self._new_future()
sslcontext = None if isinstance(ssl, bool) else ssl
protocol = aio_SSLProtocol(
self, app_protocol, sslcontext, ssl_waiter,
False, server_hostname)
else:
if server_hostname is not None:
raise ValueError('server_hostname is only meaningful with ssl')
if host is not None or port is not None:
if sock is not None:
raise ValueError(
'host/port and sock can not be specified at the same time')
fs = []
f1 = f2 = None
try:
__static_getaddrinfo(
host, port, family, uv.SOCK_STREAM,
proto, &rai_addr_static)
except LookupError:
f1 = self._getaddrinfo(
host, port, family,
uv.SOCK_STREAM, proto, flags,
0) # 0 == don't unpack
fs.append(f1)
else:
rai_static.ai_addr = &rai_addr_static
rai_static.ai_next = NULL
rai = &rai_static
if local_addr is not None:
if not isinstance(local_addr, (tuple, list)) or \
len(local_addr) != 2:
raise ValueError(
'local_addr must be a tuple of host and port')
try:
__static_getaddrinfo(
local_addr[0], local_addr[1],
family, uv.SOCK_STREAM,
proto, &lai_addr_static)
except LookupError:
f2 = self._getaddrinfo(
local_addr[0], local_addr[1], family,
uv.SOCK_STREAM, proto, flags,
0) # 0 == don't unpack
fs.append(f2)
else:
lai_static.ai_addr = &lai_addr_static
lai_static.ai_next = NULL
lai = &lai_static
if len(fs):
await aio_wait(fs, loop=self)
if rai is NULL:
ai_remote = f1.result()
if ai_remote.data is NULL:
raise OSError('getaddrinfo() returned empty list')
rai = ai_remote.data
if lai is NULL and f2 is not None:
ai_local = f2.result()
if ai_local.data is NULL:
raise OSError(
'getaddrinfo() returned empty list for local_addr')
lai = ai_local.data
exceptions = []
rai_iter = rai
while rai_iter is not NULL:
tr = None
try:
waiter = self._new_future()
tr = TCPTransport.new(self, protocol, None, waiter)
if lai is not NULL:
lai_iter = lai
while lai_iter is not NULL:
try:
tr.bind(lai_iter.ai_addr)
break
except OSError as exc:
exceptions.append(exc)
lai_iter = lai_iter.ai_next
else:
tr._close()
tr = None
rai_iter = rai_iter.ai_next
continue
tr.connect(rai_iter.ai_addr)
await waiter
except OSError as exc:
if tr is not None:
tr._close()
tr = None
exceptions.append(exc)
except:
if tr is not None:
tr._close()
tr = None
raise
else:
break
rai_iter = rai_iter.ai_next
else:
# If they all have the same str(), raise one.
model = str(exceptions[0])
if all(str(exc) == model for exc in exceptions):
raise exceptions[0]
# Raise a combined exception so the user can see all
# the various error messages.
raise OSError('Multiple exceptions: {}'.format(
', '.join(str(exc) for exc in exceptions)))
else:
if sock is None:
raise ValueError(
'host and port was not specified and no sock specified')
if not _is_sock_stream(sock.type):
raise ValueError(
'A Stream Socket was expected, got {!r}'.format(sock))
waiter = self._new_future()
tr = TCPTransport.new(self, protocol, None, waiter)
try:
# Why we use os.dup here and other places
# ---------------------------------------
#
# Prerequisite: in Python 3.6, Python Socket Objects (PSO)
# were fixed to raise an OSError if the `socket.close()` call
# failed. So if the underlying FD is already closed,
# `socket.close()` call will fail with OSError(EBADF).
#
# Problem:
#
# - Vanilla asyncio uses the passed PSO directly. When the
# transport eventually closes the PSO, the PSO is marked as
# 'closed'. If the user decides to close the PSO after
# closing the loop, everything works normal in Python 3.5
# and 3.6.
#
# - asyncio+uvloop unwraps the FD from the passed PSO.
# Eventually the transport is closed and so the FD.
# If the user decides to close the PSO after closing the
# loop, an OSError(EBADF) will be raised in Python 3.6.
#
# All in all, duping FDs makes sense, because uvloop
# (and libuv) manage the FD once the user passes a PSO to
# `loop.create_connection`. We don't want the user to have
# any control of the FD once it is passed to uvloop.
# See also: https://github.com/python/asyncio/pull/449
fileno = os_dup(sock.fileno())
# libuv will make socket non-blocking
tr._open(fileno)
tr._attach_fileobj(sock)
tr._init_protocol()
await waiter
except:
tr._close()
raise
if ssl:
await ssl_waiter
return protocol._app_transport, app_protocol
else:
return tr, protocol
async def create_unix_server(self, protocol_factory, str path=None,
*, backlog=100, sock=None, ssl=None):
"""A coroutine which creates a UNIX Domain Socket server.
The return value is a Server object, which can be used to stop
the service.
path is a str, representing a file systsem path to bind the
server socket to.
sock can optionally be specified in order to use a preexisting
socket object.
backlog is the maximum number of queued connections passed to
listen() (defaults to 100).
ssl can be set to an SSLContext to enable SSL over the
accepted connections.
"""
cdef:
UnixServer pipe
Server server = Server(self)
if ssl is not None and not isinstance(ssl, ssl_SSLContext):
raise TypeError('ssl argument must be an SSLContext or None')
if path is not None:
if sock is not None:
raise ValueError(
'path and sock can not be specified at the same time')
# We use Python sockets to create a UNIX server socket because
# when UNIX sockets are created by libuv, libuv removes the path
# they were bound to. This is different from asyncio, which
# doesn't cleanup the socket path.
sock = socket_socket(uv.AF_UNIX)
try:
sock.bind(path)
except OSError as exc:
sock.close()
if exc.errno == errno.EADDRINUSE:
# Let's improve the error message by adding
# with what exact address it occurs.
msg = 'Address {!r} is already in use'.format(path)
raise OSError(errno.EADDRINUSE, msg) from None
else:
raise
except:
sock.close()
raise
else:
if sock is None:
raise ValueError(
'path was not specified, and no sock specified')
if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
raise ValueError(
'A UNIX Domain Stream Socket was expected, got {!r}'
.format(sock))
pipe = UnixServer.new(self, protocol_factory, server, ssl)
try:
# See a comment on os_dup in create_connection
fileno = os_dup(sock.fileno())
pipe._open(fileno)
except:
pipe._close()
sock.close()
raise
pipe._attach_fileobj(sock)
try:
pipe.listen(backlog)
except:
pipe._close()
raise
server._add_server(pipe)
return server
async def create_unix_connection(self, protocol_factory, path, *,
ssl=None, sock=None,
server_hostname=None):
cdef:
UnixTransport tr
object app_protocol
object protocol
object ssl_waiter
app_protocol = protocol = protocol_factory()
ssl_waiter = None
if ssl:
if server_hostname is None:
raise ValueError('You must set server_hostname '
'when using ssl without a host')
ssl_waiter = self._new_future()
sslcontext = None if isinstance(ssl, bool) else ssl
protocol = aio_SSLProtocol(
self, app_protocol, sslcontext, ssl_waiter,
False, server_hostname)
else:
if server_hostname is not None:
raise ValueError('server_hostname is only meaningful with ssl')
if path is not None:
if isinstance(path, str):
path = PyUnicode_EncodeFSDefault(path)
if sock is not None:
raise ValueError(
'path and sock can not be specified at the same time')
waiter = self._new_future()
tr = UnixTransport.new(self, protocol, None, waiter)
tr.connect(path)
try:
await waiter
except:
tr._close()
raise
else:
if sock is None:
raise ValueError('no path and sock were specified')
if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
raise ValueError(
'A UNIX Domain Stream Socket was expected, got {!r}'
.format(sock))
waiter = self._new_future()
tr = UnixTransport.new(self, protocol, None, waiter)
try:
# See a comment on os_dup in create_connection
fileno = os_dup(sock.fileno())
# libuv will make socket non-blocking
tr._open(fileno)
tr._attach_fileobj(sock)
tr._init_protocol()
await waiter
except:
tr._close()
raise
if ssl:
await ssl_waiter
return protocol._app_transport, app_protocol
else:
return tr, protocol
def default_exception_handler(self, context):
"""Default exception handler.
This is called when an exception occurs and no exception
handler is set, and can be called by a custom exception
handler that wants to defer to the default behavior.
The context parameter has the same meaning as in
`call_exception_handler()`.
"""
message = context.get('message')
if not message:
message = 'Unhandled exception in event loop'
exception = context.get('exception')
if exception is not None:
exc_info = (type(exception), exception, exception.__traceback__)
else:
exc_info = False
log_lines = [message]
for key in sorted(context):
if key in {'message', 'exception'}:
continue
value = context[key]
if key == 'source_traceback':
tb = ''.join(tb_format_list(value))
value = 'Object created at (most recent call last):\n'
value += tb.rstrip()
else:
try:
value = repr(value)
except Exception as ex:
value = ('Exception in __repr__ {!r}; '
'value type: {!r}'.format(ex, type(value)))
log_lines.append('{}: {}'.format(key, value))
aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
def get_exception_handler(self):
"""Return an exception handler, or None if the default one is in use.
"""
return self._exception_handler
def set_exception_handler(self, handler):
"""Set handler as the new event loop exception handler.
If handler is None, the default exception handler will
be set.
If handler is a callable object, it should have a
signature matching '(loop, context)', where 'loop'
will be a reference to the active event loop, 'context'
will be a dict object (see `call_exception_handler()`
documentation for details about context).
"""
if handler is not None and not callable(handler):
raise TypeError('A callable object or None is expected, '
'got {!r}'.format(handler))
self._exception_handler = handler
def call_exception_handler(self, context):
"""Call the current event loop's exception handler.
The context argument is a dict containing the following keys:
- 'message': Error message;
- 'exception' (optional): Exception object;
- 'future' (optional): Future instance;
- 'handle' (optional): Handle instance;
- 'protocol' (optional): Protocol instance;
- 'transport' (optional): Transport instance;
- 'socket' (optional): Socket instance.
New keys maybe introduced in the future.
Note: do not overload this method in an event loop subclass.
For custom exception handling, use the
`set_exception_handler()` method.
"""
if UVLOOP_DEBUG:
self._debug_exception_handler_cnt += 1
if self._exception_handler is None:
try:
self.default_exception_handler(context)
except Exception:
# Second protection layer for unexpected errors
# in the default implementation, as well as for subclassed
# event loops with overloaded "default_exception_handler".
aio_logger.error('Exception in default exception handler',
exc_info=True)
else:
try:
self._exception_handler(self, context)
except Exception as exc:
# Exception in the user set custom exception handler.
try:
# Let's try default handler.
self.default_exception_handler({
'message': 'Unhandled error in exception handler',
'exception': exc,
'context': context,
})
except Exception:
# Guard 'default_exception_handler' in case it is
# overloaded.
aio_logger.error('Exception in default exception handler '
'while handling an unexpected error '
'in custom exception handler',
exc_info=True)
def add_reader(self, fd, callback, *args):
"""Add a reader callback."""
self._ensure_fd_no_transport(fd)
if len(args) == 0:
args = None
self._add_reader(fd, new_Handle(self, callback, args))
def remove_reader(self, fd):
"""Remove a reader callback."""
self._ensure_fd_no_transport(fd)
self._remove_reader(fd)
def add_writer(self, fd, callback, *args):
"""Add a writer callback.."""
self._ensure_fd_no_transport(fd)
if len(args) == 0:
args = None
self._add_writer(fd, new_Handle(self, callback, args))
def remove_writer(self, fd):
"""Remove a writer callback."""
self._ensure_fd_no_transport(fd)
self._remove_writer(fd)
def sock_recv(self, sock, n):
"""Receive data from the socket.
The return value is a bytes object representing the data received.
The maximum amount of data to be received at once is specified by
nbytes.
This method is a coroutine.
"""
cdef:
Handle handle
int fd
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
fut = self._new_future()
handle = new_MethodHandle3(
self,
"Loop._sock_recv",
self._sock_recv,
self,
fut, sock, n)
fd = sock.fileno()
self._add_reader(fd, handle)
return fut
async def sock_sendall(self, sock, data):
"""Send data to the socket.
The socket must be connected to a remote socket. This method continues
to send data from data until either all data has been sent or an
error occurs. None is returned on success. On error, an exception is
raised, and there is no way to determine how much data, if any, was
successfully processed by the receiving end of the connection.
This method is a coroutine.
"""
cdef:
Handle handle
int n
int fd
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
if not data:
return
try:
n = sock.send(data)
except (BlockingIOError, InterruptedError):
pass
else:
if UVLOOP_DEBUG:
# This can be a partial success, i.e. only part
# of the data was sent
self._sock_try_write_total += 1
if n == len(data):
return
if not isinstance(data, memoryview):
data = memoryview(data)
data = data[n:]
fut = self._new_future()
handle = new_MethodHandle3(
self,
"Loop._sock_sendall",
self._sock_sendall,
self,
fut, sock, data)
fd = sock.fileno()
self._add_writer(fd, handle)
return await fut
def sock_accept(self, sock):
"""Accept a connection.
The socket must be bound to an address and listening for connections.
The return value is a pair (conn, address) where conn is a new socket
object usable to send and receive data on the connection, and address
is the address bound to the socket on the other end of the connection.
This method is a coroutine.
"""
cdef:
Handle handle
int fd
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
fut = self._new_future()
handle = new_MethodHandle2(
self,
"Loop._sock_accept",
self._sock_accept,
self,
fut, sock)
fd = sock.fileno()
self._add_reader(fd, handle)
return fut
async def sock_connect(self, sock, address):
"""Connect to a remote socket at address.
This method is a coroutine.
"""
if self._debug and sock.gettimeout() != 0:
raise ValueError("the socket must be non-blocking")
fut = self._new_future()
if sock.family == uv.AF_UNIX:
self._sock_connect(fut, sock, address)
await fut
return
_, _, _, _, address = (await self.getaddrinfo(*address))[0]
self._sock_connect(fut, sock, address)
await fut
async def connect_accepted_socket(self, protocol_factory, sock, *,
ssl=None):
"""Handle an accepted connection.
This is used by servers that accept connections outside of
asyncio but that use asyncio to handle connections.
This method is a coroutine. When completed, the coroutine
returns a (transport, protocol) pair.
"""
cdef:
UVStream transport = None
if ssl is not None and not isinstance(ssl, ssl_SSLContext):
raise TypeError('ssl argument must be an SSLContext or None')
if not _is_sock_stream(sock.type):
raise ValueError(
'A Stream Socket was expected, got {!r}'.format(sock))
# See a comment on os_dup in create_connection
fileno = os_dup(sock.fileno())
app_protocol = protocol_factory()
waiter = self._new_future()
transport_waiter = None
if ssl is None:
protocol = app_protocol
transport_waiter = waiter
else:
protocol = aio_SSLProtocol(
self, app_protocol, ssl, waiter,
True, # server_side
None) # server_hostname
transport_waiter = None
if sock.family == uv.AF_UNIX:
transport = UnixTransport.new(
self, protocol, None, transport_waiter)
elif sock.family in (uv.AF_INET, uv.AF_INET6):
transport = TCPTransport.new(
self, protocol, None, transport_waiter)
if transport is None:
raise ValueError(
'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
transport._open(fileno)
transport._init_protocol()
await waiter
return transport, protocol
def run_in_executor(self, executor, func, *args):
if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
raise TypeError("coroutines cannot be used with run_in_executor()")
self._check_closed()
if executor is None:
executor = self._default_executor
if executor is None:
executor = cc_ThreadPoolExecutor()
self._default_executor = executor
new_fut = self._new_future()
_chain_future(executor.submit(func, *args), new_fut)
return new_fut
def set_default_executor(self, executor):
self._default_executor = executor
async def __subprocess_run(self, protocol_factory, args,
stdin=subprocess_PIPE,
stdout=subprocess_PIPE,
stderr=subprocess_PIPE,
universal_newlines=False,
shell=True,
bufsize=0,
preexec_fn=None,
close_fds=None,
cwd=None,
env=None,
startupinfo=None,
creationflags=0,
restore_signals=True,
start_new_session=False,
executable=None,
pass_fds=(),
# For tests only! Do not use in your code. Ever.
__uvloop_sleep_after_fork=False
):
# TODO: Implement close_fds (might not be very important in
# Python 3.5, since all FDs aren't inheritable by default.)
cdef:
int debug_flags = 0
if universal_newlines:
raise ValueError("universal_newlines must be False")
if bufsize != 0:
raise ValueError("bufsize must be 0")
if startupinfo is not None:
raise ValueError('startupinfo is not supported')
if creationflags != 0:
raise ValueError('creationflags is not supported')
if executable is not None:
args[0] = executable
if __uvloop_sleep_after_fork:
debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
waiter = self._new_future()
protocol = protocol_factory()
proc = UVProcessTransport.new(self, protocol,
args, env, cwd, start_new_session,
stdin, stdout, stderr, pass_fds,
waiter,
debug_flags,
preexec_fn,
restore_signals)
try:
await waiter
except:
proc.close()
raise
return proc, protocol
def subprocess_shell(self, protocol_factory, cmd, *,
shell=True,
**kwargs):
if not shell:
raise ValueError("shell must be True")
args = [cmd]
if shell:
args = [b'/bin/sh', b'-c'] + args
return self.__subprocess_run(protocol_factory, args, shell=True,
**kwargs)
def subprocess_exec(self, protocol_factory, program, *args,
shell=False, **kwargs):
if shell:
raise ValueError("shell must be False")
args = list((program,) + args)
return self.__subprocess_run(protocol_factory, args, shell=False,
**kwargs)
async def connect_read_pipe(self, proto_factory, pipe):
"""Register read pipe in event loop. Set the pipe to non-blocking mode.
protocol_factory should instantiate object with Protocol interface.
pipe is a file-like object.
Return pair (transport, protocol), where transport supports the
ReadTransport interface."""
cdef:
ReadUnixTransport transp
# See a comment on os_dup in create_connection
int fileno = os_dup(pipe.fileno())
waiter = self._new_future()
proto = proto_factory()
transp = ReadUnixTransport.new(self, proto, None, waiter)
transp._add_extra_info('pipe', pipe)
transp._attach_fileobj(pipe)
try:
transp._open(fileno)
transp._init_protocol()
await waiter
except:
transp.close()
raise
return transp, proto
async def connect_write_pipe(self, proto_factory, pipe):
"""Register write pipe in event loop.
protocol_factory should instantiate object with BaseProtocol interface.
Pipe is file-like object already switched to nonblocking.
Return pair (transport, protocol), where transport support
WriteTransport interface."""
cdef:
WriteUnixTransport transp
# See a comment on os_dup in create_connection
int fileno = os_dup(pipe.fileno())
waiter = self._new_future()
proto = proto_factory()
transp = WriteUnixTransport.new(self, proto, None, waiter)
transp._add_extra_info('pipe', pipe)
transp._attach_fileobj(pipe)
try:
transp._open(fileno)
transp._init_protocol()
await waiter
except:
transp.close()
raise
return transp, proto
def add_signal_handler(self, sig, callback, *args):
"""Add a handler for a signal. UNIX only.
Raise ValueError if the signal number is invalid or uncatchable.
Raise RuntimeError if there is a problem setting up the handler.
"""
cdef:
Handle h
if self._signal_handlers is None:
self._setup_signals()
if self._signal_handlers is None:
raise ValueError('set_wakeup_fd only works in main thread')
if (aio_iscoroutine(callback)
or aio_iscoroutinefunction(callback)):
raise TypeError("coroutines cannot be used "
"with add_signal_handler()")
self._check_signal(sig)
self._check_closed()
try:
# set_wakeup_fd() raises ValueError if this is not the
# main thread. By calling it early we ensure that an
# event loop running in another thread cannot add a signal
# handler.
signal_set_wakeup_fd(self._csock.fileno())
except (ValueError, OSError) as exc:
raise RuntimeError(str(exc))
h = new_Handle(self, callback, args or None)
self._signal_handlers[sig] = h
try:
signal_signal(sig, _sighandler_noop)
except OSError as exc:
del self._signal_handlers[sig]
if exc.errno == errno_EINVAL:
raise RuntimeError('sig {} cannot be caught'.format(sig))
else:
raise
def remove_signal_handler(self, sig):
"""Remove a handler for a signal. UNIX only.
Return True if a signal handler was removed, False if not.
"""
self._check_signal(sig)
if self._signal_handlers is None:
return False
try:
del self._signal_handlers[sig]
except KeyError:
return False
if sig == uv.SIGINT:
handler = signal_default_int_handler
else:
handler = signal_SIG_DFL
try:
signal_signal(sig, handler)
except OSError as exc:
if exc.errno == errno_EINVAL:
raise RuntimeError('sig {} cannot be caught'.format(sig))
else:
raise
return True
async def create_datagram_endpoint(self, protocol_factory,
local_addr=None, remote_addr=None, *,
family=0, proto=0, flags=0,
reuse_address=None, reuse_port=None,
allow_broadcast=None, sock=None):
"""A coroutine which creates a datagram endpoint.
This method will try to establish the endpoint in the background.
When successful, the coroutine returns a (transport, protocol) pair.
protocol_factory must be a callable returning a protocol instance.
socket family AF_INET or socket.AF_INET6 depending on host (or
family if specified), socket type SOCK_DGRAM.
reuse_address tells the kernel to reuse a local socket in
TIME_WAIT state, without waiting for its natural timeout to
expire. If not specified it will automatically be set to True on
UNIX.
reuse_port tells the kernel to allow this endpoint to be bound to
the same port as other existing endpoints are bound to, so long as
they all set this flag when being created. This option is not
supported on Windows and some UNIX's. If the
:py:data:`~socket.SO_REUSEPORT` constant is not defined then this
capability is unsupported.
allow_broadcast tells the kernel to allow this endpoint to send
messages to the broadcast address.
sock can optionally be specified in order to use a preexisting
socket object.
"""
cdef:
UDPTransport udp = None
system.addrinfo * lai
system.addrinfo * rai
if sock is not None:
if not _is_sock_dgram(sock.type):
raise ValueError(
'A UDP Socket was expected, got {!r}'.format(sock))
if (local_addr or remote_addr or
family or proto or flags or
reuse_address or reuse_port or allow_broadcast):
# show the problematic kwargs in exception msg
opts = dict(local_addr=local_addr, remote_addr=remote_addr,
family=family, proto=proto, flags=flags,
reuse_address=reuse_address, reuse_port=reuse_port,
allow_broadcast=allow_broadcast)
problems = ', '.join(
'{}={}'.format(k, v) for k, v in opts.items() if v)
raise ValueError(
'socket modifier keyword arguments can not be used '
'when sock is specified. ({})'.format(problems))
sock.setblocking(False)
udp = UDPTransport.__new__(UDPTransport)
udp._init(self, uv.AF_UNSPEC)
udp.open(sock.family, os_dup(sock.fileno()))
udp._attach_fileobj(sock)
else:
reuse_address = bool(reuse_address)
reuse_port = bool(reuse_port)
if reuse_port and not has_SO_REUSEPORT:
raise ValueError(
'reuse_port not supported by socket module')
lads = None
if local_addr is not None:
if (not isinstance(local_addr, (tuple, list)) or
len(local_addr) != 2):
raise TypeError(
'local_addr must be a tuple of (host, port)')
lads = await self._getaddrinfo(
local_addr[0], local_addr[1],
family, uv.SOCK_DGRAM, proto, flags,
0)
rads = None
if remote_addr is not None:
if (not isinstance(remote_addr, (tuple, list)) or
len(remote_addr) != 2):
raise TypeError(
'remote_addr must be a tuple of (host, port)')
rads = await self._getaddrinfo(
remote_addr[0], remote_addr[1],
family, uv.SOCK_DGRAM, proto, flags,
0)
excs = []
if lads is None:
if rads is not None:
udp = UDPTransport.__new__(UDPTransport)
rai = (rads).data
udp._init(self, rai.ai_family)
udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
else:
if family not in (uv.AF_INET, uv.AF_INET6):
raise ValueError('unexpected address family')
udp = UDPTransport.__new__(UDPTransport)
udp._init(self, family)
if reuse_port:
self._sock_set_reuseport(udp._fileno())
socket = udp._get_socket()
if family == uv.AF_INET6:
socket.bind(('::', 0))
else:
socket.bind(('0.0.0.0', 0))
else:
lai = (lads).data
while lai is not NULL:
try:
udp = UDPTransport.__new__(UDPTransport)
udp._init(self, lai.ai_family)
if reuse_port:
self._sock_set_reuseport(udp._fileno())
udp._bind(lai.ai_addr, reuse_address)
except Exception as ex:
lai = lai.ai_next
excs.append(ex)
continue
else:
break
else:
ctx = None
if len(excs):
ctx = excs[0]
raise OSError('could not bind to local_addr {}'.format(
local_addr)) from ctx
if rads is not None:
rai = (rads).data
sock = udp._get_socket()
while rai is not NULL:
if rai.ai_family != lai.ai_family:
rai = rai.ai_next
continue
if rai.ai_protocol != lai.ai_protocol:
rai = rai.ai_next
continue
udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
break
else:
raise OSError(
'could not bind to remote_addr {}'.format(
remote_addr))
udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
if allow_broadcast:
udp._set_broadcast(1)
protocol = protocol_factory()
waiter = self._new_future()
assert udp is not None
udp._set_protocol(protocol)
udp._set_waiter(waiter)
udp._init_protocol()
await waiter
return udp, protocol
def _asyncgen_finalizer_hook(self, agen):
self._asyncgens.discard(agen)
if not self.is_closed():
self.create_task(agen.aclose())
# Wake up the loop if the finalizer was called from
# a different thread.
self.handler_async.send()
def _asyncgen_firstiter_hook(self, agen):
if self._asyncgens_shutdown_called:
warnings_warn(
"asynchronous generator {!r} was scheduled after "
"loop.shutdown_asyncgens() call".format(agen),
ResourceWarning, source=self)
self._asyncgens.add(agen)
async def shutdown_asyncgens(self):
"""Shutdown all active asynchronous generators."""
self._asyncgens_shutdown_called = True
if self._asyncgens is None or not len(self._asyncgens):
# If Python version is <3.6 or we don't have any asynchronous
# generators alive.
return
closing_agens = list(self._asyncgens)
self._asyncgens.clear()
shutdown_coro = aio_gather(
*[ag.aclose() for ag in closing_agens],
return_exceptions=True,
loop=self)
results = await shutdown_coro
for result, agen in zip(results, closing_agens):
if isinstance(result, Exception):
self.call_exception_handler({
'message': 'an error occurred during closing of '
'asynchronous generator {!r}'.format(agen),
'exception': result,
'asyncgen': agen
})
cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle,
size_t suggested_size,
uv.uv_buf_t* buf) with gil:
cdef:
Loop loop = (uvhandle.data)._loop
if loop._recv_buffer_in_use == 1:
buf.len = 0
exc = RuntimeError('concurrent allocations')
loop._handle_exception(exc)
return
loop._recv_buffer_in_use = 1
buf.base = loop._recv_buffer
buf.len = sizeof(loop._recv_buffer)
cdef inline void __loop_free_buffer(Loop loop):
loop._recv_buffer_in_use = 0
include "cbhandles.pyx"
include "handles/handle.pyx"
include "handles/async_.pyx"
include "handles/idle.pyx"
include "handles/check.pyx"
include "handles/timer.pyx"
include "handles/poll.pyx"
include "handles/basetransport.pyx"
include "handles/stream.pyx"
include "handles/streamserver.pyx"
include "handles/tcp.pyx"
include "handles/pipe.pyx"
include "handles/process.pyx"
include "request.pyx"
include "dns.pyx"
include "handles/udp.pyx"
include "server.pyx"
include "future.pyx"
include "chain_futs.pyx"
# Used in UVProcess
cdef vint __atfork_installed = 0
cdef vint __forking = 0
cdef Loop __forking_loop = None
cdef void __atfork_child() nogil:
# See CPython/posixmodule.c for details
global __forking
with gil:
if (__forking and
__forking_loop is not None and
__forking_loop.active_process_handler is not None):
__forking_loop.active_process_handler._after_fork()
cdef __install_atfork():
global __atfork_installed
if __atfork_installed:
return
__atfork_installed = 1
cdef int err
err = system.pthread_atfork(NULL, NULL, &__atfork_child)
if err:
__atfork_installed = 0
raise convert_error(-err)
# Install PyMem* memory allocators
cdef vint __mem_installed = 0
cdef __install_pymem():
global __mem_installed
if __mem_installed:
return
__mem_installed = 1
cdef int err
err = uv.uv_replace_allocator(PyMem_RawMalloc,
PyMem_RawRealloc,
PyMem_RawCalloc,
PyMem_RawFree)
if err < 0:
__mem_installed = 0
raise convert_error(err)
def _sighandler_noop(signum, frame):
"""Dummy signal handler."""
pass
########### Stuff for tests:
async def _test_coroutine_1():
return 42
uvloop-0.8.1/uvloop/request.pxd 0000664 0003720 0003720 00000000217 13156036740 017444 0 ustar travis travis 0000000 0000000 cdef class UVRequest:
cdef:
uv.uv_req_t *request
bint done
Loop loop
cdef on_done(self)
cdef cancel(self)
uvloop-0.8.1/uvloop/_patch.py 0000664 0003720 0003720 00000003765 13156036740 017062 0 ustar travis travis 0000000 0000000 import asyncio
import sys
def _format_coroutine(coro):
if asyncio.iscoroutine(coro) \
and not hasattr(coro, 'cr_code') \
and not hasattr(coro, 'gi_code'):
# Most likely a Cython coroutine
coro_name = '{}()'.format(coro.__qualname__ or coro.__name__)
running = False
try:
running = coro.cr_running
except AttributeError:
try:
running = coro.gi_running
except AttributeError:
pass
if running:
return '{} running'.format(coro_name)
else:
return coro_name
return _old_format_coroutine(coro)
async def _wait_for_data(self, func_name):
"""Wait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
"""
if self._waiter is not None:
raise RuntimeError('%s() called while another coroutine is '
'already waiting for incoming data' % func_name)
assert not self._eof, '_wait_for_data after EOF'
# Waiting for data while paused will make deadlock, so prevent it.
if self._paused:
self._paused = False
self._transport.resume_reading()
try:
create_future = self._loop.create_future
except AttributeError:
self._waiter = asyncio.Future(loop=self._loop)
else:
self._waiter = create_future()
try:
await self._waiter
finally:
self._waiter = None
if sys.version_info < (3, 5, 3):
# This is needed to support Cython 'async def' coroutines.
from asyncio import coroutines
_old_format_coroutine = coroutines._format_coroutine
coroutines._format_coroutine = _format_coroutine
if sys.version_info < (3, 5, 2):
# Fix a possible deadlock, improve performance.
from asyncio import streams
_old_wait_for_data = streams.StreamReader._wait_for_data
_wait_for_data.__module__ = _old_wait_for_data.__module__
streams.StreamReader._wait_for_data = _wait_for_data
uvloop-0.8.1/uvloop/cbhandles.pxd 0000664 0003720 0003720 00000001065 13156036740 017701 0 ustar travis travis 0000000 0000000 cdef class Handle:
cdef:
Loop loop
bint cancelled
str meth_name
int cb_type
void *callback
object arg1, arg2, arg3, arg4
object __weakref__
readonly _source_traceback
cdef inline _set_loop(self, Loop loop)
cdef inline _run(self)
cdef _cancel(self)
cdef class TimerHandle:
cdef:
object callback, args
bint closed
UVTimer timer
Loop loop
object __weakref__
readonly _source_traceback
cdef _run(self)
cdef _cancel(self)
uvloop-0.8.1/uvloop/handles/ 0000775 0003720 0003720 00000000000 13156037661 016660 5 ustar travis travis 0000000 0000000 uvloop-0.8.1/uvloop/handles/stream.pyx 0000664 0003720 0003720 00000065000 13156036740 020713 0 ustar travis travis 0000000 0000000 DEF __PREALLOCED_BUFS = 4
@cython.no_gc_clear
@cython.freelist(DEFAULT_FREELIST_SIZE)
cdef class _StreamWriteContext:
# used to hold additional write request information for uv_write
cdef:
uv.uv_write_t req
list buffers
uv.uv_buf_t uv_bufs_sml[__PREALLOCED_BUFS]
Py_buffer py_bufs_sml[__PREALLOCED_BUFS]
bint py_bufs_sml_inuse
uv.uv_buf_t* uv_bufs
Py_buffer* py_bufs
size_t py_bufs_len
uv.uv_buf_t* uv_bufs_start
size_t uv_bufs_len
UVStream stream
bint closed
cdef free_bufs(self):
cdef size_t i
if self.uv_bufs is not NULL:
PyMem_RawFree(self.uv_bufs)
self.uv_bufs = NULL
if UVLOOP_DEBUG:
if self.py_bufs_sml_inuse:
raise RuntimeError(
'_StreamWriteContext.close: uv_bufs != NULL and '
'py_bufs_sml_inuse is True')
if self.py_bufs is not NULL:
for i from 0 <= i < self.py_bufs_len:
PyBuffer_Release(&self.py_bufs[i])
PyMem_RawFree(self.py_bufs)
self.py_bufs = NULL
if UVLOOP_DEBUG:
if self.py_bufs_sml_inuse:
raise RuntimeError(
'_StreamWriteContext.close: py_bufs != NULL and '
'py_bufs_sml_inuse is True')
if self.py_bufs_sml_inuse:
for i from 0 <= i < self.py_bufs_len:
PyBuffer_Release(&self.py_bufs_sml[i])
self.py_bufs_sml_inuse = 0
self.py_bufs_len = 0
self.buffers = None
cdef close(self):
if self.closed:
return
self.closed = 1
self.free_bufs()
Py_DECREF(self)
cdef advance_uv_buf(self, size_t sent):
# Advance the pointer to first uv_buf and the
# pointer to first byte in that buffer.
#
# We do this after a "uv_try_write" call, which
# sometimes sends only a portion of data.
# We then call "advance_uv_buf" on the write
# context, and reuse it in a "uv_write" call.
cdef:
uv.uv_buf_t* buf
size_t idx
for idx from 0 <= idx < self.uv_bufs_len:
buf = &self.uv_bufs_start[idx]
if buf.len > sent:
buf.len -= sent
buf.base = buf.base + sent
self.uv_bufs_start = buf
self.uv_bufs_len -= idx
return
else:
sent -= self.uv_bufs_start[idx].len
if UVLOOP_DEBUG:
if sent < 0:
raise RuntimeError('fatal: sent < 0 in advance_uv_buf')
raise RuntimeError('fatal: Could not advance _StreamWriteContext')
@staticmethod
cdef _StreamWriteContext new(UVStream stream, list buffers):
cdef:
_StreamWriteContext ctx
int uv_bufs_idx = 0
size_t py_bufs_len = 0
int i
Py_buffer* p_pybufs
uv.uv_buf_t* p_uvbufs
ctx = _StreamWriteContext.__new__(_StreamWriteContext)
ctx.stream = None
ctx.closed = 1
ctx.py_bufs_len = 0
ctx.py_bufs_sml_inuse = 0
ctx.uv_bufs = NULL
ctx.py_bufs = NULL
ctx.buffers = buffers
ctx.stream = stream
if len(buffers) <= __PREALLOCED_BUFS:
# We've got a small number of buffers to write, don't
# need to use malloc.
ctx.py_bufs_sml_inuse = 1
p_pybufs = &ctx.py_bufs_sml
p_uvbufs = &ctx.uv_bufs_sml
else:
for buf in buffers:
if UVLOOP_DEBUG:
if not isinstance(buf, (bytes, bytearray, memoryview)):
raise RuntimeError(
'invalid data in writebuf: an instance of '
'bytes, bytearray or memoryview was expected, '
'got {}'.format(type(buf)))
if not PyBytes_CheckExact(buf):
py_bufs_len += 1
if py_bufs_len > 0:
ctx.py_bufs = PyMem_RawMalloc(
py_bufs_len * sizeof(Py_buffer))
if ctx.py_bufs is NULL:
raise MemoryError()
ctx.uv_bufs = PyMem_RawMalloc(
len(buffers) * sizeof(uv.uv_buf_t))
if ctx.uv_bufs is NULL:
raise MemoryError()
p_pybufs = ctx.py_bufs
p_uvbufs = ctx.uv_bufs
py_bufs_len = 0
for buf in buffers:
if PyBytes_CheckExact(buf):
# We can only use this hack for bytes since it's
# immutable. For everything else it is only safe to
# use buffer protocol.
p_uvbufs[uv_bufs_idx].base = PyBytes_AS_STRING(buf)
p_uvbufs[uv_bufs_idx].len = Py_SIZE(buf)
else:
try:
PyObject_GetBuffer(
buf, &p_pybufs[py_bufs_len], PyBUF_SIMPLE)
except:
# This shouldn't ever happen, as `UVStream._write`
# casts non-bytes objects to `memoryviews`.
ctx.py_bufs_len = py_bufs_len
ctx.free_bufs()
raise
p_uvbufs[uv_bufs_idx].base = p_pybufs[py_bufs_len].buf
p_uvbufs[uv_bufs_idx].len = p_pybufs[py_bufs_len].len
py_bufs_len += 1
uv_bufs_idx += 1
ctx.uv_bufs_start = p_uvbufs
ctx.uv_bufs_len = uv_bufs_idx
ctx.py_bufs_len = py_bufs_len
ctx.req.data = ctx
if UVLOOP_DEBUG:
stream._loop._debug_stream_write_ctx_total += 1
stream._loop._debug_stream_write_ctx_cnt += 1
# Do incref after everything else is done.
# Under no circumstances we want `ctx` to be GCed while
# libuv is still working with `ctx.uv_bufs`.
Py_INCREF(ctx)
ctx.closed = 0
return ctx
def __dealloc__(self):
if not self.closed:
# Because we do an INCREF in _StreamWriteContext.new,
# __dealloc__ shouldn't ever happen with `self.closed == 1`
raise RuntimeError(
'open _StreamWriteContext is being deallocated')
if UVLOOP_DEBUG:
if self.stream is not None:
self.stream._loop._debug_stream_write_ctx_cnt -= 1
self.stream = None
@cython.no_gc_clear
cdef class UVStream(UVBaseTransport):
def __cinit__(self):
self.__shutting_down = 0
self.__reading = 0
self.__read_error_close = 0
self._eof = 0
self._buffer = []
self._buffer_size = 0
cdef inline _shutdown(self):
cdef int err
if self.__shutting_down:
return
self.__shutting_down = 1
self._ensure_alive()
self._shutdown_req.data = self
err = uv.uv_shutdown(&self._shutdown_req,
self._handle,
__uv_stream_on_shutdown)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef inline _accept(self, UVStream server):
cdef int err
self._ensure_alive()
err = uv.uv_accept(server._handle,
self._handle)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
self._on_accept()
cdef inline _close_on_read_error(self):
self.__read_error_close = 1
cdef bint _is_reading(self):
return self.__reading
cdef _start_reading(self):
cdef int err
self._ensure_alive()
if self.__reading:
return
err = uv.uv_read_start(self._handle,
__loop_alloc_buffer,
__uv_stream_on_read)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
else:
# UVStream must live until the read callback is called
self.__reading_started()
cdef inline __reading_started(self):
if self.__reading:
return
self.__reading = 1
Py_INCREF(self)
cdef inline __reading_stopped(self):
if not self.__reading:
return
self.__reading = 0
Py_DECREF(self)
cdef _stop_reading(self):
cdef int err
if not self.__reading:
return
self._ensure_alive()
# From libuv docs:
# This function is idempotent and may be safely
# called on a stopped stream.
err = uv.uv_read_stop(self._handle)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
else:
self.__reading_stopped()
cdef inline _try_write(self, object data):
cdef:
ssize_t written
bint used_buf = 0
Py_buffer py_buf
void* buf
size_t blen
int saved_errno
int fd
if (self._handle).write_queue_size != 0:
raise RuntimeError(
'UVStream._try_write called with data in uv buffers')
if PyBytes_CheckExact(data):
# We can only use this hack for bytes since it's
# immutable. For everything else it is only safe to
# use buffer protocol.
buf = PyBytes_AS_STRING(data)
blen = Py_SIZE(data)
else:
PyObject_GetBuffer(data, &py_buf, PyBUF_SIMPLE)
used_buf = 1
buf = py_buf.buf
blen = py_buf.len
if blen == 0:
# Empty data, do nothing.
return 0
fd = self._fileno()
# Use `unistd.h/write` directly, it's faster than
# uv_try_write -- less layers of code. The error
# checking logic is copied from libuv.
written = system.write(fd, buf, blen)
while written == -1 and (errno.errno == errno.EINTR or
(system.PLATFORM_IS_APPLE and
errno.errno == errno.EPROTOTYPE)):
# From libuv code (unix/stream.c):
# Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
# EPROTOTYPE can be returned while trying to write to a socket
# that is shutting down. If we retry the write, we should get
# the expected EPIPE instead.
written = system.write(fd, buf, blen)
saved_errno = errno.errno
if used_buf:
PyBuffer_Release(&py_buf)
if written < 0:
if saved_errno == errno.EAGAIN or \
saved_errno == system.EWOULDBLOCK:
return -1
else:
exc = convert_error(-saved_errno)
self._fatal_error(exc, True)
return
if UVLOOP_DEBUG:
self._loop._debug_stream_write_tries += 1
if written == blen:
return 0
return written
cdef inline _write(self, object data):
cdef int dlen
if not PyBytes_CheckExact(data):
data = memoryview(data).cast('b')
dlen = len(data)
if not dlen:
return
self._buffer_size += dlen
self._buffer.append(data)
if (not self._protocol_paused and
(self._handle).write_queue_size == 0 and
self._buffer_size > self._high_water):
# Fast-path. If:
# - the protocol isn't yet paused,
# - there is no data in libuv buffers for this stream,
# - the protocol will be paused if we continue to buffer data
#
# Then:
# - Try to write all buffered data right now.
all_sent = self._exec_write()
if UVLOOP_DEBUG:
if self._buffer_size != 0 or self._buffer != []:
raise RuntimeError(
'_buffer_size is not 0 after a successful _exec_write')
# There is no need to call `_queue_write` anymore,
# as `uv_write` should be called already.
if not all_sent:
# If not all of the data was sent successfully,
# we might need to pause the protocol.
self._maybe_pause_protocol()
return
self._maybe_pause_protocol()
self._loop._queue_write(self)
cdef inline _exec_write(self):
cdef:
int err
int buf_len
_StreamWriteContext ctx = None
if self._closed:
# If the handle is closed, just return, it's too
# late to do anything.
return
buf_len = len(self._buffer)
if not buf_len:
return
if (self._handle).write_queue_size == 0:
# libuv internal write buffers for this stream are empty.
if buf_len == 1:
# If we only have one piece of data to send, let's
# use our fast implementation of try_write.
data = self._buffer[0]
sent = self._try_write(data)
if sent is None:
# A `self._fatal_error` was called.
# It might not raise an exception under some
# conditions.
self._buffer_size = 0
self._buffer.clear()
if not self._closing:
# This should never happen.
raise RuntimeError(
'stream is open after UVStream._try_write '
'returned None')
return
if sent == 0:
# All data was successfully written.
self._buffer_size = 0
self._buffer.clear()
# on_write will call "maybe_resume_protocol".
self._on_write()
return True
if sent > 0:
if UVLOOP_DEBUG:
if sent == len(data):
raise RuntimeError(
'_try_write sent all data and returned '
'non-zero')
if PyBytes_CheckExact(data):
# Cast bytes to memoryview to avoid copying
# data that wasn't sent.
data = memoryview(data)
data = data[sent:]
self._buffer_size -= sent
self._buffer[0] = data
# At this point it's either data was sent partially,
# or an EAGAIN has happened.
else:
ctx = _StreamWriteContext.new(self, self._buffer)
err = uv.uv_try_write(self._handle,
ctx.uv_bufs_start,
ctx.uv_bufs_len)
if err > 0:
# Some data was successfully sent.
if err == self._buffer_size:
# Everything was sent.
ctx.close()
self._buffer.clear()
self._buffer_size = 0
# on_write will call "maybe_resume_protocol".
self._on_write()
return True
try:
# Advance pointers to uv_bufs in `ctx`,
# we will reuse it soon for a uv_write
# call.
ctx.advance_uv_buf(err)
except Exception as ex: # This should never happen.
# Let's try to close the `ctx` anyways.
ctx.close()
self._fatal_error(ex, True)
self._buffer.clear()
self._buffer_size = 0
return
elif err != uv.UV_EAGAIN:
ctx.close()
exc = convert_error(err)
self._fatal_error(exc, True)
self._buffer.clear()
self._buffer_size = 0
return
# fall through
if ctx is None:
ctx = _StreamWriteContext.new(self, self._buffer)
err = uv.uv_write(&ctx.req,
self._handle,
ctx.uv_bufs_start,
ctx.uv_bufs_len,
__uv_stream_on_write)
self._buffer_size = 0
# Can't use `_buffer.clear()` here: `ctx` holds a reference to
# the `_buffer`.
self._buffer = []
if err < 0:
# close write context
ctx.close()
exc = convert_error(err)
self._fatal_error(exc, True)
return
self._maybe_resume_protocol()
cdef size_t _get_write_buffer_size(self):
if self._handle is NULL:
return 0
return ((self._handle).write_queue_size +
self._buffer_size)
cdef _close(self):
try:
self._stop_reading()
finally:
UVSocketHandle._close(self)
cdef inline _on_accept(self):
# Ultimately called by __uv_stream_on_listen.
self._init_protocol()
cdef inline _on_read(self, bytes buf):
# Any exception raised here will be caught in
# __uv_stream_on_read.
self._protocol_data_received(buf)
cdef inline _on_eof(self):
# Any exception raised here will be caught in
# __uv_stream_on_read.
try:
meth = self._protocol.eof_received
except AttributeError:
keep_open = False
else:
keep_open = meth()
if keep_open:
# We're keeping the connection open so the
# protocol can write more, but we still can't
# receive more, so remove the reader callback.
self._stop_reading()
else:
self.close()
cdef inline _on_write(self):
self._maybe_resume_protocol()
if not self._get_write_buffer_size():
if self._closing:
self._schedule_call_connection_lost(None)
elif self._eof:
self._shutdown()
cdef inline _init(self, Loop loop, object protocol, Server server,
object waiter):
self._start_init(loop)
if protocol is None:
raise TypeError('protocol is required')
self._set_protocol(protocol)
if server is not None:
self._set_server(server)
if waiter is not None:
self._set_waiter(waiter)
cdef inline _on_connect(self, object exc):
# Called from __tcp_connect_callback (tcp.pyx) and
# __pipe_connect_callback (pipe.pyx).
if exc is None:
self._init_protocol()
else:
if self._waiter is None:
self._fatal_error(exc, False, "connect failed")
elif self._waiter.cancelled():
# Connect call was cancelled; just close the transport
# silently.
self._close()
elif self._waiter.done():
self._fatal_error(exc, False, "connect failed")
else:
self._waiter.set_exception(exc)
self._close()
# === Public API ===
def __repr__(self):
return '<{} closed={} reading={} {:#x}>'.format(
self.__class__.__name__,
self._closed,
self.__reading,
id(self))
def write(self, object buf):
self._ensure_alive()
if self._eof:
raise RuntimeError('Cannot call write() after write_eof()')
if not buf:
return
if self._conn_lost:
self._conn_lost += 1
return
self._write(buf)
def writelines(self, bufs):
self._ensure_alive()
if self._eof:
raise RuntimeError('Cannot call writelines() after write_eof()')
if self._conn_lost:
self._conn_lost += 1
return
for buf in bufs:
self._write(buf)
def write_eof(self):
self._ensure_alive()
if self._eof:
return
self._eof = 1
if not self._get_write_buffer_size():
self._shutdown()
def can_write_eof(self):
return True
def pause_reading(self):
self._ensure_alive()
if self._closing:
raise RuntimeError('Cannot pause_reading() when closing')
if not self._is_reading():
raise RuntimeError('Already paused')
self._stop_reading()
def resume_reading(self):
self._ensure_alive()
if self._is_reading():
raise RuntimeError('Not paused')
if self._closing:
return
self._start_reading()
cdef void __uv_stream_on_shutdown(uv.uv_shutdown_t* req,
int status) with gil:
# callback for uv_shutdown
if req.data is NULL:
aio_logger.error(
'UVStream.shutdown callback called with NULL req.data, status=%r',
status)
return
cdef UVStream stream = req.data
if status < 0 and status != uv.UV_ECANCELED:
# From libuv source code:
# The ECANCELED error code is a lie, the shutdown(2) syscall is a
# fait accompli at this point. Maybe we should revisit this in
# v0.11. A possible reason for leaving it unchanged is that it
# informs the callee that the handle has been destroyed.
if UVLOOP_DEBUG:
stream._loop._debug_stream_shutdown_errors_total += 1
exc = convert_error(status)
stream._fatal_error(exc, False,
"error status in uv_stream_t.shutdown callback")
return
cdef inline void __uv_stream_on_read_impl(uv.uv_stream_t* stream,
ssize_t nread,
const uv.uv_buf_t* buf):
cdef:
UVStream sc = stream.data
Loop loop = sc._loop
# It's OK to free the buffer early, since nothing will
# be able to touch it until this method is done.
__loop_free_buffer(loop)
if sc._closed:
# The stream was closed, there is no reason to
# do any work now.
sc.__reading_stopped() # Just in case.
return
if nread == uv.UV_EOF:
# From libuv docs:
# The callee is responsible for stopping closing the stream
# when an error happens by calling uv_read_stop() or uv_close().
# Trying to read from the stream again is undefined.
try:
if UVLOOP_DEBUG:
loop._debug_stream_read_eof_total += 1
sc._stop_reading()
sc._on_eof()
except BaseException as ex:
if UVLOOP_DEBUG:
loop._debug_stream_read_eof_cb_errors_total += 1
sc._error(ex, False)
finally:
return
if nread == 0:
# From libuv docs:
# nread might be 0, which does not indicate an error or EOF.
# This is equivalent to EAGAIN or EWOULDBLOCK under read(2).
return
if nread < 0:
# From libuv docs:
# The callee is responsible for stopping closing the stream
# when an error happens by calling uv_read_stop() or uv_close().
# Trying to read from the stream again is undefined.
#
# Therefore, we're closing the stream. Since "UVHandle._close()"
# doesn't raise exceptions unless uvloop is built with DEBUG=1,
# we don't need try...finally here.
if UVLOOP_DEBUG:
loop._debug_stream_read_errors_total += 1
if sc.__read_error_close:
# Used for getting notified when a pipe is closed.
# See WriteUnixTransport for the explanation.
sc._on_eof()
return
exc = convert_error(nread)
sc._fatal_error(exc, False,
"error status in uv_stream_t.read callback")
return
try:
if UVLOOP_DEBUG:
loop._debug_stream_read_cb_total += 1
sc._on_read(loop._recv_buffer[:nread])
except BaseException as exc:
if UVLOOP_DEBUG:
loop._debug_stream_read_cb_errors_total += 1
sc._error(exc, False)
cdef inline void __uv_stream_on_write_impl(uv.uv_write_t* req, int status):
cdef:
_StreamWriteContext ctx = <_StreamWriteContext> req.data
UVStream stream = ctx.stream
ctx.close()
if stream._closed:
# The stream was closed, there is nothing to do.
# Even if there is an error, like EPIPE, there
# is no reason to report it.
return
if status < 0:
if UVLOOP_DEBUG:
stream._loop._debug_stream_write_errors_total += 1
exc = convert_error(status)
stream._fatal_error(exc, False,
"error status in uv_stream_t.write callback")
return
try:
stream._on_write()
except BaseException as exc:
if UVLOOP_DEBUG:
stream._loop._debug_stream_write_cb_errors_total += 1
stream._error(exc, False)
cdef void __uv_stream_on_read(uv.uv_stream_t* stream,
ssize_t nread,
const uv.uv_buf_t* buf) with gil:
if __ensure_handle_data(stream,
"UVStream read callback") == 0:
return
cdef:
Loop loop = stream.loop.data
# Don't need try-finally, __uv_stream_on_read_impl is void
__uv_stream_on_read_impl(stream, nread, buf)
cdef void __uv_stream_on_write(uv.uv_write_t* req, int status) with gil:
if UVLOOP_DEBUG:
if req.data is NULL:
aio_logger.error(
'UVStream.write callback called with NULL req.data, status=%r',
status)
return
cdef:
Loop loop = (<_StreamWriteContext> req.data).stream._loop
# Don't need try-finally, __uv_stream_on_write_impl is void
__uv_stream_on_write_impl(req, status)
uvloop-0.8.1/uvloop/handles/pipe.pxd 0000664 0003720 0003720 00000001402 13156036740 020324 0 ustar travis travis 0000000 0000000 cdef class UnixServer(UVStreamServer):
cdef bind(self, str path)
@staticmethod
cdef UnixServer new(Loop loop, object protocol_factory, Server server,
object ssl)
cdef class UnixTransport(UVStream):
@staticmethod
cdef UnixTransport new(Loop loop, object protocol, Server server,
object waiter)
cdef connect(self, char* addr)
cdef class ReadUnixTransport(UVStream):
@staticmethod
cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
object waiter)
cdef class WriteUnixTransport(UVStream):
@staticmethod
cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
object waiter)
uvloop-0.8.1/uvloop/handles/handle.pxd 0000664 0003720 0003720 00000002030 13156036740 020620 0 ustar travis travis 0000000 0000000 cdef class UVHandle:
cdef:
uv.uv_handle_t *_handle
bint _closed
bint _inited
Loop _loop
readonly _source_traceback
# All "inline" methods are final
cdef inline _start_init(self, Loop loop)
cdef inline _abort_init(self)
cdef inline _finish_init(self)
cdef inline bint _is_alive(self)
cdef inline _ensure_alive(self)
cdef _error(self, exc, throw)
cdef _fatal_error(self, exc, throw, reason=?)
cdef _warn_unclosed(self)
cdef inline _free(self)
cdef _close(self)
cdef class UVSocketHandle(UVHandle):
cdef:
# Points to a Python file-object that should be closed
# when the transport is closing. Used by pipes. This
# should probably be refactored somehow.
object _fileobj
object __cached_socket
# All "inline" methods are final
cdef inline _fileno(self)
cdef _new_socket(self)
cdef inline _get_socket(self)
cdef inline _attach_fileobj(self, object file)
cdef _open(self, int sockfd)
uvloop-0.8.1/uvloop/handles/check.pxd 0000664 0003720 0003720 00000000424 13156036740 020447 0 ustar travis travis 0000000 0000000 cdef class UVCheck(UVHandle):
cdef:
Handle h
bint running
# All "inline" methods are final
cdef _init(self, Loop loop, Handle h)
cdef inline stop(self)
cdef inline start(self)
@staticmethod
cdef UVCheck new(Loop loop, Handle h)
uvloop-0.8.1/uvloop/handles/streamserver.pyx 0000664 0003720 0003720 00000007320 13156036740 022143 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVStreamServer(UVSocketHandle):
def __cinit__(self):
self.opened = 0
self._server = None
self.ssl = None
self.protocol_factory = None
cdef inline _init(self, Loop loop, object protocol_factory,
Server server, object ssl):
if ssl is not None and not isinstance(ssl, ssl_SSLContext):
raise TypeError(
'ssl is expected to be None or an instance of '
'ssl.SSLContext, got {!r}'.format(ssl))
self.ssl = ssl
self._start_init(loop)
self.protocol_factory = protocol_factory
self._server = server
cdef inline listen(self, backlog):
cdef int err
self._ensure_alive()
if not isinstance(backlog, int):
# Don't allow floats
raise TypeError('integer argument expected, got {}'.format(
type(backlog).__name__))
if self.protocol_factory is None:
raise RuntimeError('unable to listen(); no protocol_factory')
if self.opened != 1:
raise RuntimeError('unopened TCPServer')
err = uv.uv_listen( self._handle,
backlog,
__uv_streamserver_on_listen)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef inline _on_listen(self):
cdef UVStream slient
protocol = self.protocol_factory()
if self.ssl is None:
client = self._make_new_transport(protocol, None)
else:
waiter = self._loop._new_future()
ssl_protocol = aio_SSLProtocol(
self._loop, protocol, self.ssl,
waiter,
True, # server_side
None) # server_hostname
client = self._make_new_transport(ssl_protocol, None)
waiter.add_done_callback(
ft_partial(self.__on_ssl_connected, client))
client._accept(self)
cdef _fatal_error(self, exc, throw, reason=None):
# Overload UVHandle._fatal_error
self._close()
if not isinstance(exc, (BrokenPipeError,
ConnectionResetError,
ConnectionAbortedError)):
if throw or self._loop is None:
raise exc
msg = 'Fatal error on server {}'.format(
self.__class__.__name__)
if reason is not None:
msg = '{} ({})'.format(msg, reason)
self._loop.call_exception_handler({
'message': msg,
'exception': exc,
})
cdef inline _mark_as_open(self):
self.opened = 1
cdef UVStream _make_new_transport(self, object protocol, object waiter):
raise NotImplementedError
def __on_ssl_connected(self, transport, fut):
exc = fut.exception()
if exc is not None:
transport._force_close(exc)
cdef void __uv_streamserver_on_listen(uv.uv_stream_t* handle,
int status) with gil:
# callback for uv_listen
if __ensure_handle_data(handle,
"UVStream listen callback") == 0:
return
cdef:
UVStreamServer stream = handle.data
if status < 0:
if UVLOOP_DEBUG:
stream._loop._debug_stream_listen_errors_total += 1
exc = convert_error(status)
stream._fatal_error(exc, False,
"error status in uv_stream_t.listen callback")
return
try:
stream._on_listen()
except BaseException as exc:
stream._error(exc, False)
uvloop-0.8.1/uvloop/handles/timer.pyx 0000664 0003720 0003720 00000004312 13156036740 020537 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVTimer(UVHandle):
cdef _init(self, Loop loop, method_t callback, object ctx,
uint64_t timeout):
cdef int err
self._start_init(loop)
self._handle = PyMem_RawMalloc(sizeof(uv.uv_timer_t))
if self._handle is NULL:
self._abort_init()
raise MemoryError()
err = uv.uv_timer_init(self._loop.uvloop, self._handle)
if err < 0:
self._abort_init()
raise convert_error(err)
self._finish_init()
self.callback = callback
self.ctx = ctx
self.running = 0
self.timeout = timeout
cdef stop(self):
cdef int err
if not self._is_alive():
self.running = 0
return
if self.running == 1:
err = uv.uv_timer_stop(self._handle)
self.running = 0
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef start(self):
cdef int err
self._ensure_alive()
if self.running == 0:
# Update libuv internal time.
uv.uv_update_time(self._loop.uvloop) # void
err = uv.uv_timer_start(self._handle,
__uvtimer_callback,
self.timeout, 0)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
self.running = 1
@staticmethod
cdef UVTimer new(Loop loop, method_t callback, object ctx,
uint64_t timeout):
cdef UVTimer handle
handle = UVTimer.__new__(UVTimer)
handle._init(loop, callback, ctx, timeout)
return handle
cdef void __uvtimer_callback(uv.uv_timer_t* handle) with gil:
if __ensure_handle_data(handle, "UVTimer callback") == 0:
return
cdef:
UVTimer timer = handle.data
method_t cb = timer.callback
timer.running = 0
try:
cb(timer.ctx)
except BaseException as ex:
timer._error(ex, False)
uvloop-0.8.1/uvloop/handles/pipe.pyx 0000664 0003720 0003720 00000014074 13156036740 020362 0 ustar travis travis 0000000 0000000 cdef __pipe_init_uv_handle(UVStream handle, Loop loop):
cdef int err
handle._handle = \
PyMem_RawMalloc(sizeof(uv.uv_pipe_t))
if handle._handle is NULL:
handle._abort_init()
raise MemoryError()
# Initialize pipe handle with ipc=0.
# ipc=1 means that libuv will use recvmsg/sendmsg
# instead of recv/send.
err = uv.uv_pipe_init(handle._loop.uvloop,
handle._handle,
0)
if err < 0:
handle._abort_init()
raise convert_error(err)
handle._finish_init()
cdef __pipe_open(UVStream handle, int fd):
cdef int err
err = uv.uv_pipe_open(handle._handle,
fd)
if err < 0:
exc = convert_error(err)
raise exc
cdef __pipe_get_socket(UVSocketHandle handle):
fileno = handle._fileno()
return socket_socket(uv.AF_UNIX, uv.SOCK_STREAM, 0, fileno)
@cython.no_gc_clear
cdef class UnixServer(UVStreamServer):
@staticmethod
cdef UnixServer new(Loop loop, object protocol_factory, Server server,
object ssl):
cdef UnixServer handle
handle = UnixServer.__new__(UnixServer)
handle._init(loop, protocol_factory, server, ssl)
__pipe_init_uv_handle(handle, loop)
return handle
cdef _new_socket(self):
return __pipe_get_socket(self)
cdef _open(self, int sockfd):
self._ensure_alive()
__pipe_open(self, sockfd)
self._mark_as_open()
cdef bind(self, str path):
cdef int err
self._ensure_alive()
err = uv.uv_pipe_bind(self._handle,
path.encode())
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
self._mark_as_open()
cdef UVStream _make_new_transport(self, object protocol, object waiter):
cdef UnixTransport tr
tr = UnixTransport.new(self._loop, protocol, self._server, waiter)
return tr
@cython.no_gc_clear
cdef class UnixTransport(UVStream):
@staticmethod
cdef UnixTransport new(Loop loop, object protocol, Server server,
object waiter):
cdef UnixTransport handle
handle = UnixTransport.__new__(UnixTransport)
handle._init(loop, protocol, server, waiter)
__pipe_init_uv_handle(handle, loop)
return handle
cdef _new_socket(self):
return __pipe_get_socket(self)
cdef _open(self, int sockfd):
__pipe_open(self, sockfd)
cdef connect(self, char* addr):
cdef _PipeConnectRequest req
req = _PipeConnectRequest(self._loop, self)
req.connect(addr)
@cython.no_gc_clear
cdef class ReadUnixTransport(UVStream):
@staticmethod
cdef ReadUnixTransport new(Loop loop, object protocol, Server server,
object waiter):
cdef ReadUnixTransport handle
handle = ReadUnixTransport.__new__(ReadUnixTransport)
handle._init(loop, protocol, server, waiter)
__pipe_init_uv_handle(handle, loop)
return handle
cdef _new_socket(self):
return __pipe_get_socket(self)
cdef _open(self, int sockfd):
__pipe_open(self, sockfd)
def get_write_buffer_limits(self):
raise NotImplementedError
def set_write_buffer_limits(self, high=None, low=None):
raise NotImplementedError
def get_write_buffer_size(self):
raise NotImplementedError
def write(self, data):
raise NotImplementedError
def writelines(self, list_of_data):
raise NotImplementedError
def write_eof(self):
raise NotImplementedError
def can_write_eof(self):
raise NotImplementedError
def abort(self):
raise NotImplementedError
@cython.no_gc_clear
cdef class WriteUnixTransport(UVStream):
@staticmethod
cdef WriteUnixTransport new(Loop loop, object protocol, Server server,
object waiter):
cdef WriteUnixTransport handle
handle = WriteUnixTransport.__new__(WriteUnixTransport)
# We listen for read events on write-end of the pipe. When
# the read-end is close, the uv_stream_t.read callback will
# receive an error -- we want to silence that error, and just
# close the transport.
handle._close_on_read_error()
handle._init(loop, protocol, server, waiter)
__pipe_init_uv_handle(handle, loop)
return handle
cdef _new_socket(self):
return __pipe_get_socket(self)
cdef _open(self, int sockfd):
__pipe_open(self, sockfd)
def pause_reading(self):
raise NotImplementedError
def resume_reading(self):
raise NotImplementedError
cdef class _PipeConnectRequest(UVRequest):
cdef:
UnixTransport transport
def __cinit__(self, loop, transport):
self.request = PyMem_RawMalloc(sizeof(uv.uv_connect_t))
if self.request is NULL:
self.on_done()
raise MemoryError()
self.request.data = self
self.transport = transport
cdef connect(self, char* addr):
# uv_pipe_connect returns void
uv.uv_pipe_connect(self.request,
self.transport._handle,
addr,
__pipe_connect_callback)
cdef void __pipe_connect_callback(uv.uv_connect_t* req, int status) with gil:
cdef:
_PipeConnectRequest wrapper
UnixTransport transport
wrapper = <_PipeConnectRequest> req.data
transport = wrapper.transport
if status < 0:
exc = convert_error(status)
else:
exc = None
try:
transport._on_connect(exc)
except BaseException as ex:
wrapper.transport._error(ex, False)
finally:
wrapper.on_done()
uvloop-0.8.1/uvloop/handles/basetransport.pxd 0000664 0003720 0003720 00000002527 13156036740 022267 0 ustar travis travis 0000000 0000000 cdef class UVBaseTransport(UVSocketHandle):
cdef:
readonly bint _closing
bint _protocol_connected
bint _protocol_paused
object _protocol_data_received
size_t _high_water
size_t _low_water
object _protocol
Server _server
object _waiter
dict _extra_info
uint32_t _conn_lost
object __weakref__
# All "inline" methods are final
cdef inline _set_write_buffer_limits(self, int high=*, int low=*)
cdef inline _maybe_pause_protocol(self)
cdef inline _maybe_resume_protocol(self)
cdef inline _schedule_call_connection_made(self)
cdef inline _schedule_call_connection_lost(self, exc)
cdef _wakeup_waiter(self)
cdef _call_connection_made(self)
cdef _call_connection_lost(self, exc)
# Overloads of UVHandle methods:
cdef _fatal_error(self, exc, throw, reason=?)
cdef _close(self)
cdef inline _set_server(self, Server server)
cdef inline _set_waiter(self, object waiter)
cdef inline _set_protocol(self, object protocol)
cdef inline _init_protocol(self)
cdef inline _add_extra_info(self, str name, object obj)
# === overloads ===
cdef _new_socket(self)
cdef size_t _get_write_buffer_size(self)
cdef bint _is_reading(self)
cdef _start_reading(self)
cdef _stop_reading(self)
uvloop-0.8.1/uvloop/handles/poll.pxd 0000664 0003720 0003720 00000001001 13156036740 020330 0 ustar travis travis 0000000 0000000 cdef class UVPoll(UVHandle):
cdef:
int fd
Handle reading_handle
Handle writing_handle
cdef _init(self, Loop loop, int fd)
cdef _close(self)
cdef inline _poll_start(self, int flags)
cdef inline _poll_stop(self)
cdef int is_active(self)
cdef start_reading(self, Handle callback)
cdef start_writing(self, Handle callback)
cdef stop_reading(self)
cdef stop_writing(self)
cdef stop(self)
@staticmethod
cdef UVPoll new(Loop loop, int fd)
uvloop-0.8.1/uvloop/handles/udp.pyx 0000664 0003720 0003720 00000024415 13156036740 020215 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
@cython.freelist(DEFAULT_FREELIST_SIZE)
cdef class _UDPSendContext:
# used to hold additional write request information for uv_write
cdef:
uv.uv_udp_send_t req
uv.uv_buf_t uv_buf
Py_buffer py_buf
UDPTransport udp
bint closed
system.sockaddr_storage addr
cdef close(self):
if self.closed:
return
self.closed = 1
PyBuffer_Release(&self.py_buf) # void
self.req.data = NULL
Py_DECREF(self)
self.udp = None
@staticmethod
cdef _UDPSendContext new(UDPTransport udp, object data):
cdef _UDPSendContext ctx
ctx = _UDPSendContext.__new__(_UDPSendContext)
ctx.udp = None
ctx.closed = 1
ctx.req.data = ctx
Py_INCREF(ctx)
PyObject_GetBuffer(data, &ctx.py_buf, PyBUF_SIMPLE)
ctx.uv_buf = uv.uv_buf_init(ctx.py_buf.buf, ctx.py_buf.len)
ctx.udp = udp
ctx.closed = 0
return ctx
def __dealloc__(self):
if UVLOOP_DEBUG:
if not self.closed:
raise RuntimeError(
'open _UDPSendContext is being deallocated')
self.udp = None
@cython.no_gc_clear
cdef class UDPTransport(UVBaseTransport):
def __cinit__(self):
self._family = uv.AF_UNSPEC
self._address_set = 0
self.__receiving = 0
self._cached_py_address = None
cdef _init(self, Loop loop, unsigned int family):
cdef int err
self._start_init(loop)
self._handle = \
PyMem_RawMalloc(sizeof(uv.uv_udp_t))
if self._handle is NULL:
self._abort_init()
raise MemoryError()
err = uv.uv_udp_init_ex(loop.uvloop,
self._handle,
family)
if err < 0:
self._abort_init()
raise convert_error(err)
if family in (uv.AF_INET, uv.AF_INET6):
self._family = family
self._finish_init()
cdef _set_remote_address(self, system.sockaddr* addr,
size_t addr_len):
memcpy(&self._address, addr, addr_len)
self._address_set = 1
cdef open(self, int family, int sockfd):
if family in (uv.AF_INET, uv.AF_INET6):
self._family = family
else:
raise ValueError(
'cannot open a UDP handle, invalid family {}'.format(family))
cdef int err
err = uv.uv_udp_open(self._handle,
sockfd)
if err < 0:
exc = convert_error(err)
raise exc
cdef _bind(self, system.sockaddr* addr, bint reuse_addr):
cdef:
int err
int flags = 0
self._ensure_alive()
if reuse_addr:
flags |= uv.UV_UDP_REUSEADDR
err = uv.uv_udp_bind(self._handle, addr, flags)
if err < 0:
exc = convert_error(err)
raise exc
cdef _set_broadcast(self, bint on):
cdef int err
self._ensure_alive()
err = uv.uv_udp_set_broadcast(self._handle, on)
if err < 0:
exc = convert_error(err)
raise exc
cdef size_t _get_write_buffer_size(self):
if self._handle is NULL:
return 0
return (self._handle).send_queue_size
cdef bint _is_reading(self):
return self.__receiving
cdef _start_reading(self):
cdef int err
if self.__receiving:
return
self._ensure_alive()
err = uv.uv_udp_recv_start(self._handle,
__loop_alloc_buffer,
__uv_udp_on_receive)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
else:
# UDPTransport must live until the read callback is called
self.__receiving_started()
cdef _stop_reading(self):
cdef int err
if not self.__receiving:
return
self._ensure_alive()
err = uv.uv_udp_recv_stop(self._handle)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
else:
self.__receiving_stopped()
cdef inline __receiving_started(self):
if self.__receiving:
return
self.__receiving = 1
Py_INCREF(self)
cdef inline __receiving_stopped(self):
if not self.__receiving:
return
self.__receiving = 0
Py_DECREF(self)
cdef _new_socket(self):
if self._family not in (uv.AF_INET, uv.AF_INET6):
raise RuntimeError(
'UDPTransport.family is undefined; cannot create python socket')
fileno = self._fileno()
return socket_socket(self._family, uv.SOCK_STREAM, 0, fileno)
cdef _send(self, object data, object addr):
cdef:
_UDPSendContext ctx
if self._family not in (uv.AF_INET, uv.AF_INET6):
raise RuntimeError('UDPTransport.family is undefined; cannot send')
if self._address_set and addr is not None:
if self._cached_py_address is None:
self._cached_py_address = __convert_sockaddr_to_pyaddr(
&self._address)
if self._cached_py_address != addr:
raise ValueError('Invalid address: must be None or %s' %
(self._cached_py_address,))
addr = None
ctx = _UDPSendContext.new(self, data)
try:
if addr is None:
if self._address_set:
ctx.addr = self._address
else:
raise RuntimeError(
'unable to perform send operation: no address')
else:
__convert_pyaddr_to_sockaddr(self._family, addr,
&ctx.addr)
except:
ctx.close()
raise
err = uv.uv_udp_send(&ctx.req,
self._handle,
&ctx.uv_buf,
1,
&ctx.addr,
__uv_udp_on_send)
if err < 0:
ctx.close()
exc = convert_error(err)
self._fatal_error(exc, True)
cdef _on_receive(self, bytes data, object exc, object addr):
if exc is None:
self._protocol.datagram_received(data, addr)
else:
self._protocol.error_received(exc)
cdef _on_sent(self, object exc):
if exc is not None:
if isinstance(exc, OSError):
self._protocol.error_received(exc)
else:
self._fatal_error(
exc, False, 'Fatal write error on datagram transport')
self._maybe_resume_protocol()
if not self._get_write_buffer_size():
if self._closing:
self._schedule_call_connection_lost(None)
# === Public API ===
def sendto(self, data, addr=None):
if not data:
return
if self._conn_lost:
# TODO add warning
self._conn_lost += 1
return
self._send(data, addr)
self._maybe_pause_protocol()
cdef void __uv_udp_on_receive(uv.uv_udp_t* handle,
ssize_t nread,
const uv.uv_buf_t* buf,
const system.sockaddr* addr,
unsigned flags) with gil:
if __ensure_handle_data(handle,
"UDPTransport receive callback") == 0:
return
cdef:
UDPTransport udp = handle.data
Loop loop = udp._loop
bytes data
object pyaddr
# It's OK to free the buffer early, since nothing will
# be able to touch it until this method is done.
__loop_free_buffer(loop)
if udp._closed:
# The handle was closed, there is no reason to
# do any work now.
udp.__receiving_stopped() # Just in case.
return
if addr is NULL and nread == 0:
# From libuv docs:
# addr: struct sockaddr* containing the address
# of the sender. Can be NULL. Valid for the duration
# of the callback only.
# [...]
# The receive callback will be called with
# nread == 0 and addr == NULL when there is
# nothing to read, and with nread == 0 and
# addr != NULL when an empty UDP packet is
# received.
return
if addr is NULL:
pyaddr = None
else:
try:
pyaddr = __convert_sockaddr_to_pyaddr(addr)
except BaseException as exc:
udp._error(exc, False)
return
if nread < 0:
exc = convert_error(nread)
udp._on_receive(None, exc, pyaddr)
return
if pyaddr is None:
udp._fatal_error(
RuntimeError(
'uv_udp.receive callback: addr is NULL and nread >= 0'),
False)
return
if nread == 0:
data = b''
else:
data = loop._recv_buffer[:nread]
try:
udp._on_receive(data, None, pyaddr)
except BaseException as exc:
udp._error(exc, False)
cdef void __uv_udp_on_send(uv.uv_udp_send_t* req, int status) with gil:
if req.data is NULL:
# Shouldn't happen as:
# - _UDPSendContext does an extra INCREF in its 'init()'
# - _UDPSendContext holds a ref to the relevant UDPTransport
aio_logger.error(
'UVStream.write callback called with NULL req.data, status=%r',
status)
return
cdef:
_UDPSendContext ctx = <_UDPSendContext> req.data
UDPTransport udp = ctx.udp
ctx.close()
if status < 0:
exc = convert_error(status)
print(exc)
else:
exc = None
try:
udp._on_sent(exc)
except BaseException as exc:
udp._error(exc, False)
uvloop-0.8.1/uvloop/handles/stream.pxd 0000664 0003720 0003720 00000001631 13156036740 020666 0 ustar travis travis 0000000 0000000 cdef class UVStream(UVBaseTransport):
cdef:
uv.uv_shutdown_t _shutdown_req
bint __shutting_down
bint __reading
bint __read_error_close
bint _eof
list _buffer
size_t _buffer_size
# All "inline" methods are final
cdef inline _init(self, Loop loop, object protocol, Server server,
object waiter)
cdef inline _exec_write(self)
cdef inline _shutdown(self)
cdef inline _accept(self, UVStream server)
cdef inline _close_on_read_error(self)
cdef inline __reading_started(self)
cdef inline __reading_stopped(self)
cdef inline _write(self, object data)
cdef inline _try_write(self, object data)
cdef _close(self)
cdef inline _on_accept(self)
cdef inline _on_read(self, bytes buf)
cdef inline _on_eof(self)
cdef inline _on_write(self)
cdef inline _on_connect(self, object exc)
uvloop-0.8.1/uvloop/handles/tcp.pxd 0000664 0003720 0003720 00000001251 13156036740 020157 0 ustar travis travis 0000000 0000000 cdef class TCPServer(UVStreamServer):
cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
@staticmethod
cdef TCPServer new(Loop loop, object protocol_factory, Server server,
object ssl, unsigned int flags)
cdef class TCPTransport(UVStream):
cdef:
bint __peername_set
bint __sockname_set
system.sockaddr_storage __peername
system.sockaddr_storage __sockname
cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
cdef connect(self, system.sockaddr* addr)
@staticmethod
cdef TCPTransport new(Loop loop, object protocol, Server server,
object waiter)
uvloop-0.8.1/uvloop/handles/async_.pxd 0000664 0003720 0003720 00000000374 13156036740 020652 0 ustar travis travis 0000000 0000000 cdef class UVAsync(UVHandle):
cdef:
method_t callback
object ctx
cdef _init(self, Loop loop, method_t callback, object ctx)
cdef send(self)
@staticmethod
cdef UVAsync new(Loop loop, method_t callback, object ctx)
uvloop-0.8.1/uvloop/handles/idle.pyx 0000664 0003720 0003720 00000003522 13156036740 020336 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVIdle(UVHandle):
cdef _init(self, Loop loop, Handle h):
cdef int err
self._start_init(loop)
self._handle = \
PyMem_RawMalloc(sizeof(uv.uv_idle_t))
if self._handle is NULL:
self._abort_init()
raise MemoryError()
err = uv.uv_idle_init(self._loop.uvloop, self._handle)
if err < 0:
self._abort_init()
raise convert_error(err)
self._finish_init()
self.h = h
self.running = 0
cdef inline stop(self):
cdef int err
if not self._is_alive():
self.running = 0
return
if self.running == 1:
err = uv.uv_idle_stop(self._handle)
self.running = 0
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef inline start(self):
cdef int err
self._ensure_alive()
if self.running == 0:
err = uv.uv_idle_start(self._handle,
cb_idle_callback)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
self.running = 1
@staticmethod
cdef UVIdle new(Loop loop, Handle h):
cdef UVIdle handle
handle = UVIdle.__new__(UVIdle)
handle._init(loop, h)
return handle
cdef void cb_idle_callback(uv.uv_idle_t* handle) with gil:
if __ensure_handle_data(handle, "UVIdle callback") == 0:
return
cdef:
UVIdle idle = handle.data
Handle h = idle.h
try:
h._run()
except BaseException as ex:
idle._error(ex, False)
uvloop-0.8.1/uvloop/handles/process.pxd 0000664 0003720 0003720 00000004322 13156036740 021051 0 ustar travis travis 0000000 0000000 cdef class UVProcess(UVHandle):
cdef:
object _returncode
object _pid
object _errpipe_read
object _errpipe_write
object _preexec_fn
bint _restore_signals
set _fds_to_close
# Attributes used to compose uv_process_options_t:
uv.uv_process_options_t options
uv.uv_stdio_container_t[3] iocnt
list __env
char **uv_opt_env
list __args
char **uv_opt_args
char *uv_opt_file
bytes __cwd
cdef _init(self, Loop loop, list args, dict env, cwd,
start_new_session,
_stdin, _stdout, _stderr, pass_fds,
debug_flags, preexec_fn, restore_signals)
cdef _after_fork(self)
cdef char** __to_cstring_array(self, list arr)
cdef _init_args(self, list args)
cdef _init_env(self, dict env)
cdef _init_files(self, _stdin, _stdout, _stderr)
cdef _init_options(self, list args, dict env, cwd, start_new_session,
_stdin, _stdout, _stderr)
cdef _close_after_spawn(self, int fd)
cdef _on_exit(self, int64_t exit_status, int term_signal)
cdef _kill(self, int signum)
cdef class UVProcessTransport(UVProcess):
cdef:
list _exit_waiters
list _init_futs
bint _stdio_ready
list _pending_calls
object _protocol
bint _finished
WriteUnixTransport _stdin
ReadUnixTransport _stdout
ReadUnixTransport _stderr
object stdin_proto
object stdout_proto
object stderr_proto
cdef _file_redirect_stdio(self, int fd)
cdef _file_devnull(self)
cdef _file_inpipe(self)
cdef _file_outpipe(self)
cdef _check_proc(self)
cdef _pipe_connection_lost(self, int fd, exc)
cdef _pipe_data_received(self, int fd, data)
cdef _call_connection_made(self, waiter)
cdef _try_finish(self)
@staticmethod
cdef UVProcessTransport new(Loop loop, protocol, args, env, cwd,
start_new_session,
_stdin, _stdout, _stderr, pass_fds,
waiter,
debug_flags,
preexec_fn, restore_signals)
uvloop-0.8.1/uvloop/handles/async_.pyx 0000664 0003720 0003720 00000002773 13156036740 020704 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVAsync(UVHandle):
cdef _init(self, Loop loop, method_t callback, object ctx):
cdef int err
self._start_init(loop)
self._handle = \
PyMem_RawMalloc(sizeof(uv.uv_async_t))
if self._handle is NULL:
self._abort_init()
raise MemoryError()
err = uv.uv_async_init(self._loop.uvloop,
self._handle,
__uvasync_callback)
if err < 0:
self._abort_init()
raise convert_error(err)
self._finish_init()
self.callback = callback
self.ctx = ctx
cdef send(self):
cdef int err
self._ensure_alive()
err = uv.uv_async_send(self._handle)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
@staticmethod
cdef UVAsync new(Loop loop, method_t callback, object ctx):
cdef UVAsync handle
handle = UVAsync.__new__(UVAsync)
handle._init(loop, callback, ctx)
return handle
cdef void __uvasync_callback(uv.uv_async_t* handle) with gil:
if __ensure_handle_data(handle, "UVAsync callback") == 0:
return
cdef:
UVAsync async_ = handle.data
method_t cb = async_.callback
try:
cb(async_.ctx)
except BaseException as ex:
async_._error(ex, False)
uvloop-0.8.1/uvloop/handles/streamserver.pxd 0000664 0003720 0003720 00000000745 13156036740 022122 0 ustar travis travis 0000000 0000000 cdef class UVStreamServer(UVSocketHandle):
cdef:
object ssl
object protocol_factory
bint opened
Server _server
# All "inline" methods are final
cdef inline _init(self, Loop loop, object protocol_factory,
Server server, object ssl)
cdef inline _mark_as_open(self)
cdef inline listen(self, backlog)
cdef inline _on_listen(self)
cdef UVStream _make_new_transport(self, object protocol, object waiter)
uvloop-0.8.1/uvloop/handles/poll.pyx 0000664 0003720 0003720 00000014311 13156036740 020365 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVPoll(UVHandle):
cdef _init(self, Loop loop, int fd):
cdef int err
self._start_init(loop)
self._handle = \
PyMem_RawMalloc(sizeof(uv.uv_poll_t))
if self._handle is NULL:
self._abort_init()
raise MemoryError()
err = uv.uv_poll_init(self._loop.uvloop,
self._handle, fd)
if err < 0:
self._abort_init()
raise convert_error(err)
self._finish_init()
self.fd = fd
self.reading_handle = None
self.writing_handle = None
@staticmethod
cdef UVPoll new(Loop loop, int fd):
cdef UVPoll handle
handle = UVPoll.__new__(UVPoll)
handle._init(loop, fd)
return handle
cdef int is_active(self):
return (self.reading_handle is not None or
self.writing_handle is not None)
cdef inline _poll_start(self, int flags):
cdef int err
self._ensure_alive()
err = uv.uv_poll_start(
self._handle,
flags,
__on_uvpoll_event)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef inline _poll_stop(self):
cdef int err
if not self._is_alive():
return
err = uv.uv_poll_stop(self._handle)
if err < 0:
exc = convert_error(err)
self._fatal_error(exc, True)
return
cdef:
int backend_id
system.epoll_event dummy_event
if system.PLATFORM_IS_LINUX:
# libuv doesn't remove the FD from epoll immediately
# after uv_poll_stop or uv_poll_close, causing hard
# to debug issue with dup-ed file descriptors causing
# CPU burn in epoll/epoll_ctl:
# https://github.com/MagicStack/uvloop/issues/61
#
# It's safe though to manually call epoll_ctl here,
# after calling uv_poll_stop.
backend_id = uv.uv_backend_fd(self._loop.uvloop)
if backend_id != -1:
memset(&dummy_event, 0, sizeof(dummy_event))
system.epoll_ctl(
backend_id,
system.EPOLL_CTL_DEL,
self.fd,
&dummy_event) # ignore errors
cdef start_reading(self, Handle callback):
cdef:
int mask = 0
if self.reading_handle is None:
# not reading right now, setup the handle
mask = uv.UV_READABLE
if self.writing_handle is not None:
# are we writing right now?
mask |= uv.UV_WRITABLE
self._poll_start(mask)
else:
self.reading_handle._cancel()
self.reading_handle = callback
cdef start_writing(self, Handle callback):
cdef:
int mask = 0
if self.writing_handle is None:
# not writing right now, setup the handle
mask = uv.UV_WRITABLE
if self.reading_handle is not None:
# are we reading right now?
mask |= uv.UV_READABLE
self._poll_start(mask)
else:
self.writing_handle._cancel()
self.writing_handle = callback
cdef stop_reading(self):
if self.reading_handle is None:
return False
self.reading_handle._cancel()
self.reading_handle = None
if self.writing_handle is None:
self.stop()
else:
self._poll_start(uv.UV_WRITABLE)
return True
cdef stop_writing(self):
if self.writing_handle is None:
return False
self.writing_handle._cancel()
self.writing_handle = None
if self.reading_handle is None:
self.stop()
else:
self._poll_start(uv.UV_READABLE)
return True
cdef stop(self):
if self.reading_handle is not None:
self.reading_handle._cancel()
self.reading_handle = None
if self.writing_handle is not None:
self.writing_handle._cancel()
self.writing_handle = None
self._poll_stop()
cdef _close(self):
if self.is_active():
self.stop()
UVHandle._close(self)
cdef _fatal_error(self, exc, throw, reason=None):
try:
if self.reading_handle is not None:
try:
self.reading_handle._run()
except BaseException as ex:
self._loop._handle_exception(ex)
self.reading_handle = None
if self.writing_handle is not None:
try:
self.writing_handle._run()
except BaseException as ex:
self._loop._handle_exception(ex)
self.writing_handle = None
finally:
self._close()
cdef void __on_uvpoll_event(uv.uv_poll_t* handle,
int status, int events) with gil:
if __ensure_handle_data(handle, "UVPoll callback") == 0:
return
cdef:
UVPoll poll = handle.data
if status < 0:
exc = convert_error(status)
poll._fatal_error(exc, False)
return
if ((events & (uv.UV_READABLE | uv.UV_DISCONNECT)) and
poll.reading_handle is not None):
try:
if UVLOOP_DEBUG:
poll._loop._poll_read_events_total += 1
poll.reading_handle._run()
except BaseException as ex:
if UVLOOP_DEBUG:
poll._loop._poll_read_cb_errors_total += 1
poll._error(ex, False)
# continue code execution
if ((events & (uv.UV_WRITABLE | uv.UV_DISCONNECT)) and
poll.writing_handle is not None):
try:
if UVLOOP_DEBUG:
poll._loop._poll_write_events_total += 1
poll.writing_handle._run()
except BaseException as ex:
if UVLOOP_DEBUG:
poll._loop._poll_write_cb_errors_total += 1
poll._error(ex, False)
uvloop-0.8.1/uvloop/handles/udp.pxd 0000664 0003720 0003720 00000001341 13156036740 020161 0 ustar travis travis 0000000 0000000 cdef class UDPTransport(UVBaseTransport):
cdef:
bint __receiving
int _family
bint _address_set
system.sockaddr_storage _address
object _cached_py_address
cdef _init(self, Loop loop, unsigned int family)
cdef _set_remote_address(self, system.sockaddr* addr,
size_t addr_len)
cdef _bind(self, system.sockaddr* addr, bint reuse_addr)
cdef open(self, int family, int sockfd)
cdef _set_broadcast(self, bint on)
cdef inline __receiving_started(self)
cdef inline __receiving_stopped(self)
cdef _send(self, object data, object addr)
cdef _on_receive(self, bytes data, object exc, object addr)
cdef _on_sent(self, object exc)
uvloop-0.8.1/uvloop/handles/idle.pxd 0000664 0003720 0003720 00000000422 13156036740 020305 0 ustar travis travis 0000000 0000000 cdef class UVIdle(UVHandle):
cdef:
Handle h
bint running
# All "inline" methods are final
cdef _init(self, Loop loop, Handle h)
cdef inline stop(self)
cdef inline start(self)
@staticmethod
cdef UVIdle new(Loop loop, Handle h)
uvloop-0.8.1/uvloop/handles/basetransport.pyx 0000664 0003720 0003720 00000023220 13156036740 022305 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVBaseTransport(UVSocketHandle):
def __cinit__(self):
# Flow control
self._high_water = FLOW_CONTROL_HIGH_WATER
self._low_water = FLOW_CONTROL_LOW_WATER
self._protocol = None
self._protocol_connected = 0
self._protocol_paused = 0
self._protocol_data_received = None
self._server = None
self._waiter = None
self._extra_info = None
self._conn_lost = 0
self._closing = 0
cdef size_t _get_write_buffer_size(self):
return 0
cdef inline _schedule_call_connection_made(self):
self._loop._call_soon_handle(
new_MethodHandle(self._loop,
"UVTransport._call_connection_made",
self._call_connection_made,
self))
cdef inline _schedule_call_connection_lost(self, exc):
self._loop._call_soon_handle(
new_MethodHandle1(self._loop,
"UVTransport._call_connection_lost",
self._call_connection_lost,
self, exc))
cdef _fatal_error(self, exc, throw, reason=None):
# Overload UVHandle._fatal_error
self._force_close(exc)
if not isinstance(exc, (BrokenPipeError,
ConnectionResetError,
ConnectionAbortedError)):
if throw or self._loop is None:
raise exc
msg = 'Fatal error on transport {}'.format(
self.__class__.__name__)
if reason is not None:
msg = '{} ({})'.format(msg, reason)
self._loop.call_exception_handler({
'message': msg,
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
cdef inline _set_write_buffer_limits(self, int high=-1, int low=-1):
if high == -1:
if low == -1:
high = FLOW_CONTROL_HIGH_WATER
else:
high = FLOW_CONTROL_LOW_WATER
if low == -1:
low = high // 4
if not high >= low >= 0:
raise ValueError('high (%r) must be >= low (%r) must be >= 0' %
(high, low))
self._high_water = high
self._low_water = low
self._maybe_pause_protocol()
cdef inline _maybe_pause_protocol(self):
cdef:
size_t size = self._get_write_buffer_size()
if size <= self._high_water:
return
if not self._protocol_paused:
self._protocol_paused = 1
try:
self._protocol.pause_writing()
except Exception as exc:
self._loop.call_exception_handler({
'message': 'protocol.pause_writing() failed',
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
cdef inline _maybe_resume_protocol(self):
cdef:
size_t size = self._get_write_buffer_size()
if self._protocol_paused and size <= self._low_water:
self._protocol_paused = 0
try:
self._protocol.resume_writing()
except Exception as exc:
self._loop.call_exception_handler({
'message': 'protocol.resume_writing() failed',
'exception': exc,
'transport': self,
'protocol': self._protocol,
})
cdef _wakeup_waiter(self):
if self._waiter is not None:
if not self._waiter.cancelled():
self._waiter.set_result(True)
self._waiter = None
cdef _call_connection_made(self):
cdef Py_ssize_t _loop_ready_len
if self._protocol is None:
raise RuntimeError(
'protocol is not set, cannot call connection_made()')
_loop_ready_len = self._loop._ready_len
# Set _protocol_connected to 1 before calling "connection_made":
# if transport is aborted or closed, "connection_lost" will
# still be scheduled.
self._protocol_connected = 1
try:
self._protocol.connection_made(self)
except:
self._wakeup_waiter()
raise
if self._closing:
# This might happen when "transport.abort()" is called
# from "Protocol.connection_made".
self._wakeup_waiter()
return
if _loop_ready_len == self._loop._ready_len:
# No new calls were scheduled by 'protocol.connection_made',
# so it's safe to start reading right now.
self._start_reading()
else:
# In asyncio we'd just call start_reading() right after we
# call protocol.connection_made(). However, that breaks
# SSLProtocol in uvloop, which does some initialization
# with loop.call_soon in its connection_made. It appears,
# that uvloop can call protocol.data_received() *before* it
# calls the handlers that connection_made set up.
# That's why we're using another call_soon here.
self._loop._call_soon_handle(
new_MethodHandle(self._loop,
"UVTransport._start_reading",
self._start_reading,
self))
self._wakeup_waiter()
cdef _call_connection_lost(self, exc):
if self._waiter is not None:
# This shouldn't ever happen!
self._loop.call_exception_handler({
'message': 'waiter is not None in {}._call_connection_lost'.
format(self.__class__.__name__)
})
if not self._waiter.done():
self._waiter.set_exception(exc)
self._waiter = None
if self._closed:
# The handle is closed -- likely, _call_connection_lost
# was already called before.
return
try:
if self._protocol_connected:
self._protocol.connection_lost(exc)
finally:
self._protocol = None
self._protocol_data_received = None
self._close()
server = self._server
if server is not None:
(server)._detach()
self._server = None
cdef inline _set_server(self, Server server):
self._server = server
(server)._attach()
cdef inline _set_waiter(self, object waiter):
if waiter is not None and not isfuture(waiter):
raise TypeError(
'invalid waiter object {!r}, expected asyncio.Future'.
format(waiter))
self._waiter = waiter
cdef inline _set_protocol(self, object protocol):
self._protocol = protocol
# Store a reference to the bound method directly
try:
self._protocol_data_received = protocol.data_received
except AttributeError:
pass
cdef inline _init_protocol(self):
self._loop._track_transport(self)
if self._protocol is None:
raise RuntimeError('invalid _init_protocol call')
self._schedule_call_connection_made()
cdef inline _add_extra_info(self, str name, object obj):
if self._extra_info is None:
self._extra_info = {}
self._extra_info[name] = obj
cdef bint _is_reading(self):
raise NotImplementedError
cdef _start_reading(self):
raise NotImplementedError
cdef _stop_reading(self):
raise NotImplementedError
# === Public API ===
property _paused:
# Used by SSLProto. Might be removed in the future.
def __get__(self):
return bool(not self._is_reading())
def get_protocol(self):
return self._protocol
def set_protocol(self, protocol):
self._set_protocol(protocol)
def _force_close(self, exc):
# Used by SSLProto. Might be removed in the future.
if self._conn_lost or self._closed:
return
if not self._closing:
self._closing = 1
self._stop_reading()
self._conn_lost += 1
self._schedule_call_connection_lost(exc)
def abort(self):
self._force_close(None)
def close(self):
if self._closing or self._closed:
return
self._closing = 1
self._stop_reading()
if not self._get_write_buffer_size():
# The write buffer is empty
self._conn_lost += 1
self._schedule_call_connection_lost(None)
def is_closing(self):
return self._closing
def get_write_buffer_size(self):
return self._get_write_buffer_size()
def set_write_buffer_limits(self, high=None, low=None):
self._ensure_alive()
if high is None:
high = -1
if low is None:
low = -1
self._set_write_buffer_limits(high, low)
def get_write_buffer_limits(self):
return (self._low_water, self._high_water)
def get_extra_info(self, name, default=None):
if self._extra_info is not None and name in self._extra_info:
return self._extra_info[name]
if name == 'socket':
return self._get_socket()
if name == 'sockname':
return self._get_socket().getsockname()
if name == 'peername':
try:
return self._get_socket().getpeername()
except socket_error:
return default
return default
uvloop-0.8.1/uvloop/handles/handle.pyx 0000664 0003720 0003720 00000026534 13156036740 020664 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
cdef class UVHandle:
"""A base class for all libuv handles.
Automatically manages memory deallocation and closing.
Important:
1. call "_ensure_alive()" before calling any libuv functions on
your handles.
2. call "__ensure_handle_data" in *all* libuv handle callbacks.
"""
def __cinit__(self):
self._closed = 0
self._inited = 0
self._handle = NULL
self._loop = None
self._source_traceback = None
def __init__(self):
raise TypeError(
'{} is not supposed to be instantiated from Python'.format(
self.__class__.__name__))
def __dealloc__(self):
if UVLOOP_DEBUG:
if self._loop is not None:
self._loop._debug_handles_current.subtract([
self.__class__.__name__])
else:
# No "@cython.no_gc_clear" decorator on this UVHandle
raise RuntimeError(
'{} without @no_gc_clear; loop was set to None by GC'
.format(self.__class__.__name__))
if self._handle is NULL:
return
# -> When we're at this point, something is wrong <-
if self._handle.loop is NULL:
# The handle wasn't initialized with "uv_{handle}_init"
self._closed = 1
self._free()
raise RuntimeError(
'{} is open in __dealloc__ with loop set to NULL'
.format(self.__class__.__name__))
if self._closed == 1:
# So _handle is not NULL and self._closed == 1?
raise RuntimeError(
'{}.__dealloc__: _handle is NULL, _closed == 1'.format(
self.__class__.__name__))
# The handle is dealloced while open. Let's try to close it.
# Situations when this is possible include unhandled exceptions,
# errors during Handle.__cinit__/__init__ etc.
if self._inited:
self._handle.data = NULL
uv.uv_close(self._handle, __uv_close_handle_cb) # void; no errors
self._handle = NULL
self._warn_unclosed()
else:
# The handle was allocated, but not initialized
self._closed = 1
self._free()
cdef inline _free(self):
if self._handle == NULL:
return
if UVLOOP_DEBUG:
self._loop._debug_uv_handles_freed += 1
PyMem_RawFree(self._handle)
self._handle = NULL
cdef _warn_unclosed(self):
if self._source_traceback is not None:
tb = ''.join(tb_format_list(self._source_traceback))
tb = 'object created at (most recent call last):\n{}'.format(
tb.rstrip())
msg = 'unclosed resource {!r}; {}'.format(self, tb)
else:
msg = 'unclosed resource {!r}'.format(self)
warnings_warn(msg, ResourceWarning)
cdef inline _abort_init(self):
if self._handle is not NULL:
self._free()
if UVLOOP_DEBUG:
name = self.__class__.__name__
if self._inited:
raise RuntimeError(
'_abort_init: {}._inited is set'.format(name))
if self._closed:
raise RuntimeError(
'_abort_init: {}._closed is set'.format(name))
self._closed = 1
cdef inline _finish_init(self):
self._inited = 1
self._handle.data = self
if self._loop._debug:
self._source_traceback = tb_extract_stack(sys_getframe(0))
if UVLOOP_DEBUG:
self._loop._debug_uv_handles_total += 1
cdef inline _start_init(self, Loop loop):
if UVLOOP_DEBUG:
if self._loop is not None:
raise RuntimeError(
'{}._start_init can only be called once'.format(
self.__class__.__name__))
cls_name = self.__class__.__name__
loop._debug_handles_total.update([cls_name])
loop._debug_handles_current.update([cls_name])
self._loop = loop
cdef inline bint _is_alive(self):
cdef bint res
res = self._closed != 1 and self._inited == 1
if UVLOOP_DEBUG:
if res:
name = self.__class__.__name__
if self._handle is NULL:
raise RuntimeError(
'{} is alive, but _handle is NULL'.format(name))
if self._loop is None:
raise RuntimeError(
'{} is alive, but _loop is None'.format(name))
if self._handle.loop is not self._loop.uvloop:
raise RuntimeError(
'{} is alive, but _handle.loop is not '
'initialized'.format(name))
if self._handle.data is not self:
raise RuntimeError(
'{} is alive, but _handle.data is not '
'initialized'.format(name))
return res
cdef inline _ensure_alive(self):
if not self._is_alive():
raise RuntimeError(
'unable to perform operation on {!r}; '
'the handler is closed'.format(self))
cdef _fatal_error(self, exc, throw, reason=None):
# Fatal error means an error that was returned by the
# underlying libuv handle function. We usually can't
# recover from that, hence we just close the handle.
self._close()
if throw or self._loop is None:
raise exc
else:
self._loop._handle_exception(exc)
cdef _error(self, exc, throw):
# A non-fatal error is usually an error that was caught
# by the handler, but was originated in the client code
# (not in libuv). In this case we either want to simply
# raise or log it.
if throw or self._loop is None:
raise exc
else:
self._loop._handle_exception(exc)
cdef _close(self):
if self._closed == 1:
return
self._closed = 1
if self._handle is NULL:
return
if UVLOOP_DEBUG:
if self._handle.data is NULL:
raise RuntimeError(
'{}._close: _handle.data is NULL'.format(
self.__class__.__name__))
if