def truncate(self, length: int = 0) -> asyncio.Future:
if self.__fileno < 0:
raise asyncio.InvalidStateError('AIOFile closed')
return run_in_thread(os.ftruncate,
self.__fileno,
length,
loop=self.__loop)
def open_fd(self, fd: int):
if self.__fileno == AIO_FILE_CLOSED:
raise asyncio.InvalidStateError('AIOFile closed')
if self.__fileno != AIO_FILE_NOT_OPENED:
raise RuntimeError('Already opened')
self.__fileno = fd
def test_dup_send_success(app, aps, ieee):
req = app._pending[253] = MagicMock()
req.result.set_result.side_effect = asyncio.InvalidStateError()
app.ezsp_callback_handler(
"messageSentHandler",
[t.EmberIncomingMessageType.INCOMING_MULTICAST, 0xBEED, aps, 253, 0, b""],
)
assert req.result.set_exception.call_count == 0
assert req.result.set_result.call_count == 1
def result(self, *args, **kwargs) -> T:
# The asyncio Future may have completed before the concurrent one
if self.future.done():
return self.future.result()
# Don't allow waiting in the unsync.thread loop since it will deadlock
if threading.current_thread() == unsync.thread and not self.concurrent_future.done():
raise asyncio.InvalidStateError("Calling result() in an unsync method is not allowed")
# Wait on the concurrent Future outside unsync.thread
return self.concurrent_future.result(*args, **kwargs)
async def _write(self, request: RequestType) -> None:
if self.done():
raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
if self._done_writing_flag:
raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS)
if not self._metadata_sent.is_set():
await self._metadata_sent.wait()
if self.done():
await self._raise_for_status()
serialized_request = _common.serialize(request,
self._request_serializer)
try:
await self._cython_call.send_serialized_message(serialized_request)
except asyncio.CancelledError:
if not self.cancelled():
self.cancel()
await self._raise_for_status()
async def send_code(self, code: str):
"""
send_code sends `code` as back-script to peer's hosting endpoint for landing by its hosting
environment. Only side effects are expected from landing of `code` at peer site.
Note this can only be called in `send` stage, and from the dedicated hosting aio task, i.e.
from functions exposed to the hosting environment and called by the peer-scripting-code from
the remote posting conversation which triggered this ho co.
"""
if self._send_done_fut is None or self._send_done_fut.done():
raise asyncio.InvalidStateError("ho co not in send stage")
hbic = self._hbic
if self is not hbic._sender:
raise asyncio.InvalidStateError("ho co not current sender")
await hbic._send_packet(code)
async def recv_obj(self):
"""
recv_obj returns the landed result of a piece of peer-scripting-code sent by calling
PoCo.send_obj() with the remote posting conversation which triggered this ho co.
Note this can only be called in `recv` stage, and from the dedicated hosting aio task, i.e.
from functions exposed to the hosting environment and called by the peer-scripting-code from
the remote posting conversation which triggered this ho co.
"""
if self._recv_done_fut.done():
raise asyncio.InvalidStateError("ho co not in recv stage")
hbic = self._hbic
if self is not hbic._recver:
raise asyncio.InvalidStateError("ho co not current recver")
return await hbic._recv_one_obj(self.he)
def xrlrs(self, xrlrs: int):
if not self.locked():
raise asyncio.InvalidStateError()
now = time.time()
xrlrs = int(xrlrs)
if self._xra is None or xrlrs < self._xrlrs or self._xra <= now:
self._xra = now + RATE.block + RATE.bpad
self._xrlrs = xrlrs
if xrlrs >= RATE.requests - RATE.rpad:
self.defer()
async def open(self):
if self.__fileno == AIO_FILE_CLOSED:
raise asyncio.InvalidStateError('AIOFile closed')
if self.__fileno != AIO_FILE_NOT_OPENED:
return
self.__fileno = os.open(self.__fname,
flags=self.mode.flags,
mode=self.__access_mode)
def cancel(self):
if self._state == c._CANCELLED:
raise asyncio.InvalidStateError("already cancelled")
self._state = c._CANCELLED
if self.process_handle is not None:
if not self.process_handle._cancelled:
self.process_handle.cancel()
self._cancel_transfer_tasks()
self.__protocol_connected = False
async def _ho_co_finish_recv(self, co: HoCo):
assert co is self._recver, "ho co not current recver ?!"
assert not co._recv_done_fut.done(), "ho co finishing recv twice ?!"
pkt = await self._recv_packet()
if pkt is None:
raise asyncio.InvalidStateError("hbic disconnected")
payload, wire_dir = pkt
if wire_dir != "co_end":
raise asyncio.InvalidStateError(
f"Extra packet not landed by ho co before leaving recv stage: [{payload!s}#{wire_dir!s}]"
)
if payload != co._co_seq:
raise asyncio.InvalidStateError("co seq mismatch on co_end")
# signal co_keeper to start receiving next co
co._recv_done_fut.set_result(None)
def result(self) -> _Any:
if self._task is not None:
raise _asyncio.InvalidStateError("ServerHandler still running")
exc = self.exception()
if exc is not None:
raise exc
return self._result
def test_receive_reply_after_timeout(prot_hndl):
callback_mock = MagicMock(spec_set=asyncio.Future)
callback_mock.set_result.side_effect = asyncio.InvalidStateError()
prot_hndl._awaiting[0] = (0, prot_hndl.COMMANDS["version"][2], callback_mock)
prot_hndl(b"\x00\xff\x00\x04\x05\x06")
assert 0 not in prot_hndl._awaiting
assert callback_mock.set_exception.call_count == 0
assert callback_mock.set_result.call_count == 1
callback_mock.set_result.assert_called_once_with([4, 5, 6])
assert prot_hndl.cb_mock.call_count == 0
async def fsync(self):
if self.__fileno < 0:
raise asyncio.InvalidStateError('AIOFile closed')
return (
await self.OPERATION_CLASS(
self.IO_NOP,
self.__fileno, 0, 0,
self.__loop
)
)
async def send_obj(self, code: str):
"""
send_obj sends `code` to peer's hosting endpoint for landing by its hosting environment, and
the landed value to be received by calling PoCo.recv_obj() with the remote posting conversation
which triggered this ho co.
Note this can only be called in `send` stage, and from the dedicated hosting aio task, i.e.
from functions exposed to the hosting environment and called by the peer-scripting-code from
the remote posting conversation which triggered this ho co.
"""
if self._send_done_fut is None or self._send_done_fut.done():
raise asyncio.InvalidStateError("ho co not in send stage")
hbic = self._hbic
if self is not hbic._sender:
raise asyncio.InvalidStateError("ho co not current sender")
await hbic._send_packet(code, b"co_recv")
def on_cok_done(fut):
cok_exc = fut.exception()
if cok_exc is not None:
logger.error(f"Unexpected failure in co_keeper: {cok_exc!s}")
if not self._conn_fut.done():
self._conn_fut.set_exception(
cok_exc or asyncio.InvalidStateError("co_keeper exit"))
if not self._disc_fut.done():
self._disc_fut.set_result(None)
if wire.is_connected():
wire.disconnect()
def local_port(self) -> str:
transport = self.transport
if transport is None:
raise asyncio.InvalidStateError("Socket not wired!")
sockname = transport.get_extra_info("sockname")
if len(sockname) in (2, 4):
return sockname[1]
raise NotImplementedError(
"Socket transport other than tcp4/tcp6 not supported yet."
)
def remote_host(self) -> str:
transport = self.transport
if transport is None:
raise asyncio.InvalidStateError("Socket not wired!")
peername = transport.get_extra_info("peername")
if len(peername) in (2, 4):
return peername[0]
raise NotImplementedError(
"Socket transport other than tcp4/tcp6 not supported yet."
)
def test_receive_reply_after_timeout(ezsp_f):
ezsp_f.handle_callback = mock.MagicMock()
callback_mock = mock.MagicMock(spec_set=asyncio.Future)
callback_mock.set_result.side_effect = asyncio.InvalidStateError()
ezsp_f._awaiting[0] = (0, ezsp_f.COMMANDS['version'][2], callback_mock)
ezsp_f.frame_received(b'\x00\xff\x00\x04\x05\x06')
assert 0 not in ezsp_f._awaiting
assert callback_mock.set_exception.call_count == 0
assert callback_mock.set_result.call_count == 1
callback_mock.set_result.assert_called_once_with([4, 5, 6])
assert ezsp_f.handle_callback.call_count == 0
def test_cancelled_future(self):
"""Ensures that cancelled futures are handled appropriately."""
data = struct.pack("!H", len(self.response)) + self.response
mock_future = unittest.mock.MagicMock(asyncio.Future)
client_tcp = DNSClientProtocolTCP(self.dnsq, mock_future, "10.0.0.0")
client_tcp.time_stamp = 1000000
# If the future is cancelled, set_result raises InvalidStateError.
mock_future.set_result.side_effect = asyncio.InvalidStateError(
"CANCELLED: <Future cancelled>")
client_tcp.data_received(data)
async def write(self, request: RequestType) -> None:
# If no queue was created it means that requests
# should be expected through an iterators provided
# by the caller.
if self._write_to_iterator_queue is None:
raise cygrpc.UsageError(_API_STYLE_ERROR)
try:
call = await self._interceptors_task
except (asyncio.CancelledError, AioRpcError):
raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
if call.done():
raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
elif call._done_writing_flag:
raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS)
await self._write_to_iterator_queue_interruptible(request, call)
if call.done():
raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
async def open(self):
if self.__file_obj is not None:
return
if self.__file_obj and self.__file_obj.closed:
raise asyncio.InvalidStateError("AIOFile closed")
self.__file_obj = await self._run_in_thread(
open, self.__fname, self.__open_mode,
)
return self.fileno()
def exception(self) -> _Optional[BaseException]:
if self._task is not None:
raise _asyncio.InvalidStateError("ServerHandler still running")
if self._exception is None:
return None
if isinstance(self._exception, _asyncio.CancelledError):
raise self._exception
return self._exception
async def recv_obj(self):
"""
recv_obj returns the landed result of a piece of back-script `code` sent with the triggered
hosting conversation at remote site via HoCo.send_obj(code)
Note this can only be called in `recv` stage, and from the aio task which created this
conversation.
"""
if not self._send_done_fut.done():
raise asyncio.InvalidStateError("po co still in send stage")
if self._recv_done_fut is None:
raise asyncio.InvalidStateError("po co not in recv stage")
assert self._begin_acked_fut.done(), "po co response not started ?!"
hbic = self._hbic
assert self is hbic._recver, "po co not current recver ?!"
return await hbic._recv_one_obj(self.he)
def result(self) -> Any:
"""Return the result of this assertion.
The semantics is similar to that of the `result()` method of `asyncio.Task`
(https://docs.python.org/3/library/asyncio-task.html#task-object):
If the assertion is done, the result of the assertion coroutine is returned
or the exception raised by the coroutine is re-raised.
If the assertion is not done (in particular, if hasn't been started) then
this method raises `asyncio.InvalidStateError`.
"""
if not self._task:
raise asyncio.InvalidStateError("Assertion not started")
return self._task.result()
def __aiter__(self) -> AsyncIterator[E]:
"""Return an asynchronous generator of events.
It will yield events to `async for` loops in assertion coroutines.
For a given assertion `A`, `A.__iter__()` is guaranteed to return
the same asynchronous generator every time it's called.
"""
if self._ready is None or self._processed is None:
raise asyncio.InvalidStateError("Assertion not started")
if self._generator is None:
self._generator = self._create_generator()
return self._generator
def cancel_task(self, instance: TaskInstance):
"""
Request cancellation of a specific instance of a scheduled task.
This method will not immediately stop and delete the task. The cancellation will be queued
in the asyncio event loop. You can await instance.wait() if you need to be sure the
cancellation has completed.
:param instance: The task instance (returned by :meth:`~.schedule_task_at` and
:meth:`~.schedule_task_in`) to cancel.
:raise asyncio.InvalidStateError: Task is already done, does not exist or was previously
cancelled.
"""
try:
self.tasks[instance.task][instance.timestamp].async_task.cancel()
except KeyError:
raise asyncio.InvalidStateError(
"Task {!s} does not exist, is finished or cancelled".format(
instance))
except TypeError:
raise asyncio.InvalidStateError(
"Task was not started (??? should not happen?)".format(
instance))
async def read(self) -> ResponseType:
if self._status.done():
await self._raise_for_status()
raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
response_message = await self._read()
if response_message is None:
# If the read operation failed, Core should explain why.
await self._raise_for_status()
# If no exception raised, there is something wrong internally.
assert False, 'Read operation failed with StatusCode.OK'
else:
return response_message
async def __aexit__(self, exc_type, exc_val, exc_tb):
hbic = self._hbic
co = self._co
if not hbic.is_connected():
raise asyncio.InvalidStateError(
f"hbic disconnected due to: {hbic.disc_reason!s}"
)
if not co._send_done_fut.done():
await hbic._po_co_finish_send(co)
recv_done_fut = co._recv_done_fut
if recv_done_fut is not None:
recv_done_fut.set_result(None)
async def recv_data(
self,
bufs: Union[bytearray, memoryview,
# or sequence of them, i.e. streaming on-the-fly
Sequence[Union[bytearray, memoryview]], ],
):
"""
recv_data receives the binary data/stream sent by calling PoCo.send_data()
with the remote posting conversation which triggered this ho co.
Note this can only be called in `recv` stage, and from the dedicated hosting aio task, i.e.
from functions exposed to the hosting environment and called by the peer-scripting-code from
the remote posting conversation which triggered this ho co.
"""
if self._recv_done_fut.done():
raise asyncio.InvalidStateError("ho co not in recv stage")
hbic = self._hbic
if self is not hbic._recver:
raise asyncio.InvalidStateError("ho co not current recver")
await hbic._recv_data(bufs)
