async def __asubscribe__(self, observer: AsyncObserver) -> AsyncDisposable:
task = None
assert isinstance(observer, AsyncObserver)
async def cancel():
task.cancel()
sub = AsyncDisposable(cancel)
async def worker() -> None:
async for value in self.iterable:
try:
await observer.asend(value)
except Exception as ex:
await observer.athrow(ex)
return
await observer.aclose()
try:
task = asyncio.ensure_future(worker())
except Exception as ex:
log.debug("FromIterable:worker(), Exception: %s" % ex)
await observer.athrow(ex)
return sub
async def __asubscribe__(self, observer: AsyncObserver) -> AsyncDisposable:
async def cancel() -> None:
if self._subscription is not None:
await self._subscription.adispose()
if self._task is not None:
self._task.cancel()
self._task = asyncio.ensure_future(self.worker(observer))
return AsyncDisposable(cancel)
async def __asubscribe__(self, observer: AsyncObserver) -> AsyncDisposable:
tasks = [] # type: List[asyncio.Task]
sink = Delay.Sink(self, tasks)
down = await chain(sink, observer)
up = await chain(self._source, sink)
async def cancel():
for task in tasks:
task.cancel()
return AsyncCompositeDisposable(up, down, AsyncDisposable(cancel))
async def __asubscribe__(self, observer) -> AsyncDisposable:
"""Start streaming."""
async def worker(value) -> None:
"""Task for sending value."""
try:
log.debug("Unit:__asubscribe__:worker:sending: %s", str(value))
await observer.asend(value)
except Exception as ex:
try:
await observer.athrow(ex)
except Exception as ex:
log.error("Unhandled exception: ", ex)
return
await observer.aclose()
async def done() -> None:
"""Called when future resolves."""
try:
value = self._value.result()
except asyncio.CancelledError:
await observer.aclose()
except Exception as ex:
try:
await observer.athrow(ex)
except Exception as ex:
log.error("Unhandled exception: ", ex)
return
else:
await worker(value)
def done_callback(fut):
asyncio.ensure_future(done())
async def dispose():
if hasattr(self._value, "remove_done_callback"):
self._value.remove_done_callback(done_callback)
disposable = AsyncDisposable(dispose)
# Check if plain value or Future (async value)
if hasattr(self._value, "add_done_callback"):
self._value.add_done_callback(done_callback)
else:
asyncio.ensure_future(worker(self._value))
log.debug("Unit:done")
return disposable
async def __asubscribe__(self, observer: AsyncObserver) -> AsyncDisposable:
return AsyncDisposable()