def filter_stderr(popen:subprocess.Popen, future:asyncio.Future):
last_ex = None
while True:
data = popen.stderr.readline()
if data:
log.ffmpeg("Data from ffmpeg: {}".format(data))
try:
if check_stderr(data):
sys.stderr.buffer.write(data)
sys.stderr.buffer.flush()
except FFmpegError as e:
log.ffmpeg("Error from ffmpeg: %s", str(e).strip())
last_ex = e
except FFmpegWarning:
pass # useless message
else:
break
if last_ex:
future.set_exception(last_ex)
else:
future.set_result(True)
class TextInputDialog:
"""Hello, this is doc"""
def __init__(self, title="", label_text="", completer=None):
self.future = Future()
def accept_text(buf):
buf.complete_state = None
self.future.set_result(self.text_area.text)
if self.text_area.text == "":
get_app().exit()
self.text_area = TextArea(
completer=completer,
multiline=False,
width=D(preferred=40),
accept_handler=accept_text,
)
self.dialog = Dialog(
title=title,
body=HSplit(
[Label(text=label_text), self.text_area,
Label(text="")]),
width=D(preferred=75),
modal=True,
)
def __pt_container__(self):
return self.dialog
def as_future(fun, *args, **kwargs):
"""
Executes a function with the given arguments
and wraps the result into a future.
:param fun: The function to be called.
:type fun: func
:param args: The argument list for the supplied function.
:type args: list
:param kwargs: The keyword argument dict for the supplied function.
:type kwargs: dict
:return: The functions result wrapped in a Future
:rtype: asyncio.Future
"""
try:
res = fun(*args, **kwargs)
except Exception as e:
f = Future()
f.set_exception(e)
return f
else:
if isinstance(res, Future):
return res
elif iscoroutine(res):
return asyncio.Task(res)
else:
f = Future()
f.set_result(res)
return f
def async_return(result):
"""
Return an object which can be used in an 'await' expression.
"""
f = Future()
f.set_result(result)
return f
class ConfirmationDialog:
def __init__(self, title, text, yes_text, no_text, button=None):
self.future = Future()
def yes_handler():
self.future.set_result(True)
def no_handler():
self.future.set_result(None)
self.buttons = [
Button(text=yes_text, handler=yes_handler),
Button(text=no_text, handler=no_handler),
]
if button:
self.buttons.insert(
1, Button(text=button[0], handler=lambda: button[1](self)))
self.dialog = Dialog(
title=title,
body=HSplit([Label(text=text)]),
buttons=self.buttons,
width=D(preferred=50),
modal=True,
)
def __pt_container__(self):
return self.dialog
def __wrapper(*args, **kw):
if iscoroutinefunction(func):
return ensure_future(func(*args, **kw))
future = Future()
future.set_result(func(*args, **kw))
return future
async def main(f: asyncio.Future):
await asyncio.sleep(1)
try:
f.set_result('I have finished.')
except RuntimeError as e:
print(f'No longer allowed: {e}')
f.cancel()
def _wait_handler(self, _future: asyncio.Future, _keys: [str], **kwargs):
for key in _keys:
self.remove_handler_by_key(key)
if _future.cancelled():
return
_future.set_result(result=kwargs)
def mock_get_reg(_: HomeAssistant) -> Awaitable[EntityRegistry]:
MockReg = Mock(spec=EntityRegistry)
mock_reg = MockReg()
mock_reg.configure_mock(entities={})
future = Future()
future.set_result(mock_reg)
return future
class Tester:
def __init__(self):
self.end = Future()
def __call__(self, *args, **kwargs):
if not self.end.done():
self.end.set_result((args, kwargs))
async def start_downloader(
self,
got_descriptor_time: asyncio.Future,
downloader: StreamDownloader,
download_id: str,
outpoint: str,
claim: ClaimDict,
resolved: typing.Dict,
file_name: typing.Optional[str] = None) -> ManagedStream:
start_time = self.loop.time()
downloader.download(self.node)
await downloader.got_descriptor.wait()
got_descriptor_time.set_result(self.loop.time() - start_time)
rowid = await self._store_stream(downloader)
await self.storage.save_content_claim(
downloader.descriptor.stream_hash, outpoint)
stream = ManagedStream(self.loop,
self.blob_manager,
rowid,
downloader.descriptor,
self.config.download_dir,
file_name,
downloader,
ManagedStream.STATUS_RUNNING,
download_id=download_id)
stream.set_claim(resolved, claim)
await stream.downloader.wrote_bytes_event.wait()
self.streams.add(stream)
return stream
def filter_stderr(popen: subprocess.Popen, future: asyncio.Future):
last_ex = None
while True:
data = popen.stderr.readline()
if data:
log.ffmpeg("Data from ffmpeg: {}".format(data))
try:
if check_stderr(data):
sys.stderr.buffer.write(data)
sys.stderr.buffer.flush()
except FFmpegError as e:
log.ffmpeg("Error from ffmpeg: %s", str(e).strip())
last_ex = e
except FFmpegWarning:
pass # useless message
else:
break
if last_ex:
future.set_exception(last_ex)
else:
future.set_result(True)
def filter_stderr(popen:subprocess.Popen, future:asyncio.Future):
last_ex = None
while True:
data = popen.stderr.readline()
if data:
# print("FFmpeg says:", data, flush=True)
try:
if check_stderr(data):
sys.stderr.buffer.write(data)
sys.stderr.buffer.flush()
except FFmpegError as e:
print("Error from FFmpeg:", e)
last_ex = e
except FFmpegWarning:
pass # useless message
else:
break
if last_ex:
future.set_exception(last_ex)
else:
future.set_result(True)
class AlertDialog:
"""
Alert message with OK button
"""
def __init__(self, title, text):
"""
:param title: message title
:param text: message text
"""
self.future = Future()
def set_done():
self.future.set_result(None)
ok_button = Button(text="OK", handler=(lambda: set_done()))
self.dialog = Dialog(
title=title,
body=HSplit([Label(text=text), ]),
buttons=[ok_button],
width=D(preferred=80),
modal=True,
)
def __pt_container__(self):
return self.dialog
def set_future_result(future: Future,
result: Any) -> None: # type: ignore # pypy
if not future.done():
if isinstance(result, Exception):
future.set_exception(result)
else:
future.set_result(result)
class TextInputDialog:
def __init__(self, title='', label_text='', completer=None):
self.future = Future()
def accept_text(buf):
get_app().layout.focus(ok_button)
buf.complete_state = None
return True
def accept():
self.future.set_result(self.text_area.text)
def cancel():
self.future.set_result(None)
self.text_area = TextArea(completer=completer,
multiline=False,
width=D(preferred=40),
accept_handler=accept_text)
ok_button = Button(text='OK', handler=accept)
cancel_button = Button(text='Cancel', handler=cancel)
self.dialog = Dialog(title=title,
body=HSplit(
[Label(text=label_text), self.text_area]),
buttons=[ok_button, cancel_button],
width=D(preferred=80),
modal=True)
def __pt_container__(self):
return self.dialog
async def _wait_for_complete(self, result_future: asyncio.Future, *args,
**kwargs):
Logger.debug(tag=self._TAG, msg="_wait_for_complete() start")
# Wait for rc to be ready
future = self._engine.get_ready_future()
await future
with ThreadPoolExecutor(max_workers=1) as executor:
# Call IconServiceEngine.hello()
f = executor.submit(self._hello)
future = asyncio.wrap_future(f)
await future
# Start to sync blocks
f = executor.submit(self._run, *args, **kwargs)
f = asyncio.wrap_future(f)
for fut in asyncio.as_completed([f]):
try:
ret = await fut
except Exception as exc:
self._engine.close()
# Wait to stop ipc_server for 1s
await asyncio.sleep(1)
result_future.set_exception(exc)
else:
self._engine.close()
# Wait to stop ipc_server for 1s
await asyncio.sleep(1)
Logger.debug(tag=self._TAG,
msg="_wait_for_complete() end1")
result_future.set_result(ret)
Logger.debug(tag=self._TAG,
msg="_wait_for_complete() end2")
async def _read_partner_by_address(self, ip_address: IPv4Address,
port: int, future: asyncio.Future):
parameters = {'IP_ADDRESS': str(ip_address), 'PORT': port}
log.debug(parameters)
sql = f'SELECT * FROM {self.name} WHERE ip_address = :IP_ADDRESS AND port = :PORT AND DELETED = 0'
for row in self.connection.execute(sql, parameters):
self.data.append(PartnerEntity(**row))
future.set_result(len(self.data))
class Tester:
def __init__(self):
self.end = Future()
def __call__(self, *args, **kwargs):
if not self.end.done():
self.end.set_result((args, kwargs))
async def _execute_future(self, future: asyncio.Future,
obj: object) -> Any:
try:
res = await self.func(obj)
future.set_result(res)
except Exception as e:
future.set_exception(e)
return await future
def ask_password(self, future: asyncio.Future):
input_dialog = QtWidgets.QInputDialog()
response = input_dialog.getText(
self, "Password", "This server requires a password to join.")
if not response[1]:
future.set_exception(InterruptedError())
else:
future.set_result(response[0])
async def _run(self, future: asyncio.Future) -> None:
async with self.xmpp_client.connected() as stream:
self.stream = stream
stream.soft_timeout = datetime.timedelta(minutes=5)
stream.round_trip_time = datetime.timedelta(minutes=5)
future.set_result(None)
while True:
await asyncio.sleep(1)
def _callback(fut: asyncio.Future, result: Any, errorno: int) -> None:
if fut.cancelled():
return
if errorno is not None:
fut.set_exception(
error.DNSError(errorno, pycares.errno.strerror(errorno)))
else:
fut.set_result(result)
def set_result(future: Future, result: Any, exception: Exception) -> None:
if future.done():
return
if exception:
future.set_exception(exception)
else:
future.set_result(result)
def _handle_future(future: Future, result: object, exception: Exception):
if future.cancelled():
return
if exception is not None:
future.set_exception(exception)
else:
future.set_result(result)
async def __read_cache(fut: asyncio.Future, cache_file: Path):
try:
async with aiofiles.open(cache_file, "rb") as f:
b = await f.read()
log.info(f"cache load from {cache_file}")
fut.set_result(b)
except Exception as e:
fut.set_exception(e)
async def add(self, key, value, expires=0):
f = Future()
if self._get(key) is not None:
f.set_result(False)
else:
await self.set(key, value, expires)
f.set_result(True)
return await f
async def test_mocked_actor(mocker, loop):
m = mocker.patch('tests.test_main.DemoActor.direct_method')
r = Future(loop=loop)
r.set_result(123)
m.return_value = r
actor = DemoActor(loop=loop)
v = await actor.direct_method(1, 1)
assert v == 123
def _wait_handler(self, _future: asyncio.Future,
_keys: List[EventHandlerKey], **kwargs):
for key in _keys:
self.remove_handler_by_key(key)
if _future.cancelled():
return
_future.set_result(kwargs)
def _fulfill_future(fut: asyncio.Future, result, err: Exception = None):
"""Resolve a callback future given the result and exception, if any."""
if fut.cancelled():
LOGGER.debug("callback previously cancelled")
elif err:
fut.set_exception(err)
else:
fut.set_result(result)
async def get_subprocess(future: asyncio.Future):
process = await asyncio.create_subprocess_exec(
*runnable,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=environment
)
future.set_result(process)
class CustomWSClientProtocol(WebSocketClientProtocol):
"""Add auto-ping switch (dirty way) and let us start handshaking manually."""
# this framework mix camel and underline naming style, nice!
def __init__(self):
WebSocketClientProtocol.__init__(self)
self.customUriPath = '/'
self.customWsKey = None
self._delayedHandshake = Future()
def setAutoPing(self, interval, timeout):
"""Set auto-ping interval. Start it if it's not running."""
self.disableAutoPing()
self.autoPingInterval = interval
self.autoPingTimeout = timeout
self.autoPingPendingCall = loop.call_later(interval,
self._sendAutoPing)
def disableAutoPing(self):
if self.autoPingPendingCall:
self.autoPingPendingCall.cancel()
self.autoPingPendingCall = None
def startHandshake(self):
"""Delay handshake because some states must be set right before handshake (so
they can't be set in factory)."""
self._delayedHandshake.set_result(None)
@coroutine
def restartHandshake(self):
"""Resume delayed handshake. It enable us to customize handshake HTTP header."""
yield from wait_for(self._delayedHandshake, None)
if config.compatible:
self.websocket_key = base64.b64encode(os.urandom(16))
else:
self.websocket_key = self.customWsKey
request = [
'GET %s HTTP/1.1' % self.customUriPath,
'Host: %s:%d' % (self.factory.host, self.factory.port),
'Sec-WebSocket-Key: %s' % self.websocket_key.decode(),
'Sec-WebSocket-Version: %d' %
self.SPEC_TO_PROTOCOL_VERSION[self.version],
'Pragma: no-cache',
'Cache-Control: no-cache',
'Connection: Upgrade',
'Upgrade: WebSocket',
]
if config.compatible:
# store custom ws key in cookie to prevent it from being changed by ws proxy
request.append('Cookie: %s=%s' %
(config.cookie_key, self.customWsKey.decode()))
if self.factory.useragent:
request.append('User-Agent: %s' % self.factory.useragent)
self.http_request_data = '\r\n'.join(request).encode(
'utf8') + b'\r\n\r\n'
self.sendData(self.http_request_data)
if self.debug:
self.log.debug(request)
async def shutdown(
consumer: MetricsConsumer,
db_connection: asyncpg.connection.Connection,
is_active: asyncio.Future,
):
logger.info("Shutting down")
await consumer.stop()
await db_connection.close()
is_active.set_result(None)
async def test_scroll_error(
aes,
index_name,
):
aes = MagicMock(spec=AsyncElasticsearch)
_search_response = Future()
_search_response.set_result({
'_shards': {
'total': 5,
'successful': 5
},
'_scroll_id': 42,
'hits': {
'hits': [1, 2, 3]
},
})
aes.search.return_value = _search_response
def _scroll_response(hits):
response = Future()
response.set_result({
'_shards': {
'total': 5,
'successful': 4
},
'_scroll_id': 42,
'hits': {
'hits': hits
},
})
return response
aes.scroll.side_effect = [
_scroll_response([4, 5, 6]),
_scroll_response([])
]
data = [
h async for h in scan(aes, raise_on_error=False, clear_scroll=False)
]
assert data == [1, 2, 3, 4, 5, 6]
assert aes.scroll.call_count == 2
aes.search.reset_mock()
aes.scroll.reset_mock()
aes.scroll.side_effect = [
_scroll_response([4, 5, 6]),
_scroll_response([])
]
with raises(ScanError):
data = []
async for h in scan(aes, raise_on_error=True, clear_scroll=False):
data.append(h)
assert data == [1, 2, 3]
assert aes.scroll.call_count == 1
def side_effect(*args, **kwargs):
def _side_effect(*args, **kwargs):
fut = Future()
fut.set_result({'origin': '127.0.0.1'})
return fut
resp = Mock()
resp.json.side_effect = resp.release.side_effect = _side_effect
fut = Future()
fut.set_result(resp)
return fut
def test_json_with_async_string2(self):
d = Future()
astr = wsgi.AsyncString(d)
response = wsgi.Json({'bla': astr})
self.assertEqual(len(response.children), 1)
result = response.render()
self.assertIsInstance(result, Future)
d.set_result('ciao')
result = yield result
self.assertEqual(result, json.dumps({'bla': 'ciao'}))
def js_query(self, query) -> Future:
if self.connected:
self.js_exec(query, self._reqid)
fut = Future()
self._tasks[self._reqid] = fut
self._reqid += 1
return fut
else:
fut = Future()
fut.set_result(None)
return fut
class CustomWSClientProtocol(WebSocketClientProtocol):
"""Add auto-ping switch (dirty way) and let us start handshaking manually."""
# this framework mix camel and underline naming style, nice!
def __init__(self):
WebSocketClientProtocol.__init__(self)
self.customUriPath = '/'
self.customWsKey = None
self._delayedHandshake = Future()
def setAutoPing(self, interval, timeout):
"""Set auto-ping interval. Start it if it's not running."""
self.disableAutoPing()
self.autoPingInterval = interval
self.autoPingTimeout = timeout
self.autoPingPendingCall = loop.call_later(interval, self._sendAutoPing)
def disableAutoPing(self):
if self.autoPingPendingCall:
self.autoPingPendingCall.cancel()
self.autoPingPendingCall = None
def startHandshake(self):
"""Delay handshake because some states must be set right before handshake (so
they can't be set in factory)."""
self._delayedHandshake.set_result(None)
@coroutine
def restartHandshake(self):
"""Resume delayed handshake. It enable us to customize handshake HTTP header."""
yield from wait_for(self._delayedHandshake, None)
if config.compatible:
self.websocket_key = base64.b64encode(os.urandom(16))
else:
self.websocket_key = self.customWsKey
request = [
'GET %s HTTP/1.1' % self.customUriPath,
'Host: %s:%d' % (self.factory.host, self.factory.port),
'Sec-WebSocket-Key: %s' % self.websocket_key.decode(),
'Sec-WebSocket-Version: %d' % self.SPEC_TO_PROTOCOL_VERSION[self.version],
'Pragma: no-cache',
'Cache-Control: no-cache',
'Connection: Upgrade',
'Upgrade: WebSocket',
]
if config.compatible:
# store custom ws key in cookie to prevent it from being changed by ws proxy
request.append('Cookie: %s=%s' % (config.cookie_key, self.customWsKey.decode()))
if self.factory.useragent:
request.append('User-Agent: %s' % self.factory.useragent)
self.http_request_data = '\r\n'.join(request).encode('utf8') + b'\r\n\r\n'
self.sendData(self.http_request_data)
if self.debug:
self.log.debug(request)
def go():
future = Future()
future.set_result(42)
source = Observable.from_future(future)
def on_next(x):
success[0] = 42 == x
def on_error(err):
success[1] = False
def on_completed():
success[2] = True
subscription = source.subscribe(on_next, on_error, on_completed)
def _as_future(fun, *args, **kwargs):
try:
res = fun(*args, **kwargs)
except Exception as e:
f = Future()
f.set_exception(e)
return f
else:
if isinstance(res, Future):
return res
elif iscoroutine(res):
return asyncio.Task(res)
else:
f = Future()
f.set_result(res)
return f
def go():
future = Future()
future.set_result(42)
source = rx.from_future(future)
def on_next(x):
success[0] = x == 42
def on_error(err):
success[1] = False
def on_completed():
success[2] = True
source.subscribe(on_next, on_error, on_completed)
def go():
future = Future()
future.set_result(42)
source = rx.from_future(future)
def on_next(x):
success[0] = False
def on_error(err):
success[1] = False
def on_completed():
success[2] = False
subscription = source.subscribe(on_next, on_error, on_completed)
subscription.dispose()
async def _uwsgi_entry_point(self, current_greenlet: greenlet.greenlet, future: asyncio.Future,
*args, **kwargs):
"""
uWSGI wrapper entry point.
"""
try:
# Call the underlying wrapped function.
result = await func(self, *args, **kwargs)
except Exception as e:
# Set the exception on the Future, allowing the web server to retrieve it.
future.set_exception(e)
else:
# Set the result of the function on the Future.
future.set_result(result)
finally:
# Switch back context.
current_greenlet.switch()
def multi_future(children, quiet_exceptions=()):
"""
Wraps multiple futures in a single future.
:param quiet_exceptions:
:param children:
"""
if isinstance(children, dict):
keys = list(children.keys())
children = list(children.values())
else:
keys = None
unfinished_children = set(children)
future = Future()
if not children:
future.set_result({} if keys is not None else [])
def callback(ft):
unfinished_children.remove(ft)
if not unfinished_children:
result_list = []
for ft in children:
try:
result_list.append(ft.result())
except Exception as e:
if future.done():
if not isinstance(e, quiet_exceptions):
print("Multiple exceptions in yield list",
file=sys.stderr)
else:
future.set_exception(sys.exc_info())
if not future.done():
if keys is not None:
future.set_result(dict(list(zip(keys, result_list))))
else:
future.set_result(result_list)
listening = set()
for f in children:
if f not in listening:
listening.add(f)
f.add_done_callback(callback)
return future
async def test_ticks_pong(make_transport, make_fut):
transp = make_transport()
pong = WSMessage(type=WSMsgType.PONG, data=b"", extra="")
close = WSMessage(type=WSMsgType.closing, data=b"", extra="")
future = Future()
future.set_result(pong)
future2 = Future()
future2.set_result(close)
ws = mock.Mock()
ws.receive.side_effect = [future, future2]
session = transp.session
await transp.client(ws, session)
assert session._tick.called
class MessageDialog:
def __init__(self, title, text):
self.future = Future()
def set_done():
self.future.set_result(None)
ok_button = Button(text='OK', handler=(lambda: set_done()))
self.dialog = Dialog(
title=title,
body=HSplit([
Label(text=text),
]),
buttons=[ok_button],
width=D(preferred=80),
modal=True)
def __pt_container__(self):
return self.dialog
async def _inner_wrapper_ordered(arg, future: asyncio.Future, loop):
try:
error = None
ret = None
try:
ret = await self._coro_fun(*arg, loop=loop)
except asyncio.CancelledError as e:
raise e
except Exception as e:
error = e
if self._sema is not None:
await self._sema.acquire()
async with self._wakeup_iterator:
if error is not None:
future.set_error(ret)
else:
future.set_result(ret)
self._wakeup_iterator.notify_all()
except asyncio.CancelledError:
pass
async def test_sends_ping(make_transport, make_fut):
transp = make_transport()
future = Future()
future.set_result(False)
ws = mock.Mock()
ws.ping.side_effect = [future]
hb_future = Future()
hb_future.set_result((FRAME_HEARTBEAT, b""))
session_close_future = Future()
session_close_future.set_exception(SessionIsClosed)
session = mock.Mock()
session._wait.side_effect = [hb_future, session_close_future]
await transp.server(ws, session)
assert ws.ping.called
def wait_for_fd(fd, *, loop=None): """Given a file descriptor, block on it until we have input to read""" if hasattr(fd, 'fileno'): fd = fd.fileno() if not loop: loop = get_event_loop() waiter = Future(loop=loop) loop.add_reader(fd, lambda : waiter.set_result(None)) yield from waiter loop.remove_reader(fd)
async def _launcher(self, coro, callback_future: asyncio.Future = None):
exception = None
try:
ret = await coro
except Exception as e:
exception = e
pass
finally:
self._current_workers -= 1
while self._current_workers < self._max_workers:
waiting_future = None
while len(self._pending_queue) > 0:
generator = self._pending_queue[0]
try:
waiting_future = next(generator)
break
except StopIteration:
self._pending_queue.popleft()
continue
if waiting_future is None:
break
self._current_workers += 1
asyncio.ensure_future(waiting_future, loop=self._loop)
if self._idle():
async with self._waiter:
self._waiter.notify_all()
if exception is not None:
if callback_future is None:
raise exception
else:
callback_future.set_exception(exception)
return
if callback_future is None:
return ret
else:
callback_future.set_result(ret)
return
async def test_run_coroutine_job(asyncio_scheduler, asyncio_executor, exception):
from asyncio import Future, sleep
future = Future()
job = asyncio_scheduler.add_job(waiter, 'interval', seconds=1, args=[sleep, exception])
asyncio_executor._run_job_success = lambda job_id, events: future.set_result(events)
asyncio_executor._run_job_error = lambda job_id, exc, tb: future.set_exception(exc)
asyncio_executor.submit_job(job, [datetime.now(utc)])
events = await future
assert len(events) == 1
if exception:
assert str(events[0].exception) == 'dummy error'
else:
assert events[0].retval is True
class TextInputDialog:
def __init__(self, title='', label_text='', completer=None):
self.future = Future()
def accept_text(buf):
get_app().layout.focus(ok_button)
buf.complete_state = None
return True
def accept():
self.future.set_result(self.text_area.text)
def cancel():
self.future.set_result(None)
self.text_area = TextArea(
completer=completer,
multiline=False,
width=D(preferred=40),
accept_handler=accept_text)
ok_button = Button(text='OK', handler=accept)
cancel_button = Button(text='Cancel', handler=cancel)
self.dialog = Dialog(
title=title,
body=HSplit([
Label(text=label_text),
self.text_area
]),
buttons=[ok_button, cancel_button],
width=D(preferred=80),
modal=True)
def __pt_container__(self):
return self.dialog
class SubscriberThread(threading.Thread):
def __init__(self, topic, id):
super().__init__(target=self)
self.subscriber = Subscriber(topic=topic, id=id)
self.future = Future()
def done(self):
return self.future.done()
def result(self):
return self.future.result()
def run(self):
try:
self.subscriber.open()
result = self.loop()
self.future.set_result(result)
except Exception as error:
self.future.set_exception(error)
finally:
self.subscriber.close()
def loop(self):
raise NotImplementedError()
def wrapper(*args, **kwargs):
x = Future()
res = func(*args, **kwargs)
x.set_result(res)
return x
def resolver():
fut = Future()
fut.set_result(FactoryResolver(param.SUB_TYPE, self))
return fut
def wrapper(ft: asyncio.Future):
print('call wrapper')
res = fn(*args, **kwargs)
ft.set_result(res)
loop.stop()
def wraps_future(fut: asyncio.Future, coro):
# Yield from coroutine.
result = yield from coro
fut.set_result(result)
def success():
f = Future()
f.set_result(None)
return f
class WebSocketAdapterProtocol(asyncio.Protocol):
"""
Adapter class for asyncio-based WebSocket client and server protocols.
"""
def connection_made(self, transport):
self.transport = transport
self.receive_queue = deque()
self._consume()
try:
peer = transport.get_extra_info('peername')
try:
# FIXME: tcp4 vs tcp6
self.peer = u"tcp:%s:%d" % (peer[0], peer[1])
except:
# e.g. Unix Domain sockets don't have host/port
self.peer = u"unix:{0}".format(peer)
except:
self.peer = u"?"
self._connectionMade()
def connection_lost(self, exc):
self._connectionLost(exc)
# according to asyncio docs, connection_lost(None) is called
# if something else called transport.close()
if exc is not None:
self.transport.close()
self.transport = None
def _consume(self):
self.waiter = Future(loop=self.factory.loop or txaio.config.loop)
def process(_):
while len(self.receive_queue):
data = self.receive_queue.popleft()
if self.transport:
self._dataReceived(data)
self._consume()
self.waiter.add_done_callback(process)
def data_received(self, data):
self.receive_queue.append(data)
if not self.waiter.done():
self.waiter.set_result(None)
# noinspection PyUnusedLocal
def _closeConnection(self, abort=False):
self.transport.close()
def _onOpen(self):
res = self.onOpen()
if yields(res):
ensure_future(res)
def _onMessageBegin(self, isBinary):
res = self.onMessageBegin(isBinary)
if yields(res):
ensure_future(res)
def _onMessageFrameBegin(self, length):
res = self.onMessageFrameBegin(length)
if yields(res):
ensure_future(res)
def _onMessageFrameData(self, payload):
res = self.onMessageFrameData(payload)
if yields(res):
ensure_future(res)
def _onMessageFrameEnd(self):
res = self.onMessageFrameEnd()
if yields(res):
ensure_future(res)
def _onMessageFrame(self, payload):
res = self.onMessageFrame(payload)
if yields(res):
ensure_future(res)
def _onMessageEnd(self):
res = self.onMessageEnd()
if yields(res):
ensure_future(res)
def _onMessage(self, payload, isBinary):
res = self.onMessage(payload, isBinary)
if yields(res):
ensure_future(res)
def _onPing(self, payload):
res = self.onPing(payload)
if yields(res):
ensure_future(res)
def _onPong(self, payload):
res = self.onPong(payload)
if yields(res):
ensure_future(res)
def _onClose(self, wasClean, code, reason):
res = self.onClose(wasClean, code, reason)
if yields(res):
ensure_future(res)
def get_channel_id(self):
"""
Implements :func:`autobahn.wamp.interfaces.ITransport.get_channel_id`
"""
self.log.debug('FIXME: transport channel binding not implemented for asyncio (autobahn-python issue #729)')
return None
def registerProducer(self, producer, streaming):
raise Exception("not implemented")
class WebSocketAdapterProtocol(asyncio.Protocol):
"""
Adapter class for asyncio-based WebSocket client and server protocols.
"""
def connection_made(self, transport):
self.transport = transport
self.receive_queue = deque()
self._consume()
try:
peer = transport.get_extra_info('peername')
try:
# FIXME: tcp4 vs tcp6
self.peer = "tcp:%s:%d" % (peer[0], peer[1])
except:
# e.g. Unix Domain sockets don't have host/port
self.peer = "unix:{0}".format(peer)
except:
self.peer = "?"
self._connectionMade()
def connection_lost(self, exc):
self._connectionLost(exc)
self.transport = None
def _consume(self):
self.waiter = Future()
def process(_):
while len(self.receive_queue):
data = self.receive_queue.popleft()
if self.transport:
self._dataReceived(data)
else:
print("WebSocketAdapterProtocol._consume: no transport")
self._consume()
self.waiter.add_done_callback(process)
def data_received(self, data):
self.receive_queue.append(data)
if not self.waiter.done():
self.waiter.set_result(None)
# noinspection PyUnusedLocal
def _closeConnection(self, abort=False):
self.transport.close()
def _onOpen(self):
res = self.onOpen()
if yields(res):
asyncio.async(res)
def _onMessageBegin(self, isBinary):
res = self.onMessageBegin(isBinary)
if yields(res):
asyncio.async(res)
def _onMessageFrameBegin(self, length):
res = self.onMessageFrameBegin(length)
if yields(res):
asyncio.async(res)
def _onMessageFrameData(self, payload):
res = self.onMessageFrameData(payload)
if yields(res):
asyncio.async(res)
def _onMessageFrameEnd(self):
res = self.onMessageFrameEnd()
if yields(res):
asyncio.async(res)
def _onMessageFrame(self, payload):
res = self.onMessageFrame(payload)
if yields(res):
asyncio.async(res)
def _onMessageEnd(self):
res = self.onMessageEnd()
if yields(res):
asyncio.async(res)
def _onMessage(self, payload, isBinary):
res = self.onMessage(payload, isBinary)
if yields(res):
asyncio.async(res)
def _onPing(self, payload):
res = self.onPing(payload)
if yields(res):
asyncio.async(res)
def _onPong(self, payload):
res = self.onPong(payload)
if yields(res):
asyncio.async(res)
def _onClose(self, wasClean, code, reason):
res = self.onClose(wasClean, code, reason)
if yields(res):
asyncio.async(res)
def registerProducer(self, producer, streaming):
raise Exception("not implemented")
