Crate fuchsia_async

A futures-rs executor designed specifically for Fuchsia.

Example:

A simple, singlethreaded print server:

#[fuchsia_async::run_singlethreaded]
async fn main() {
    let op = say_world();

    // This println! will happen first
    println!("Hello...");

    // Calling `.await` on `op` starts executing `say_world`.
    op.await;
}


async fn say_world() {
    println!("...world");
}

Modules

condition

Implements a combined mutex and condition.

net

Asynchronous networking abstractions.

scope

Structured concurrency API for fuchsia-async.

test_support

Testing support for repeated runs

Macros

invoke_for_handle_types

invoke_for_handle_types!{mmm} calls the macro mmm! with two arguments: one is the name of a Zircon handle, the second is one of:

Structs

BootInstant

A time relative to the executor’s clock on the boot timeline.

Channel

An I/O object representing a Channel.

DefaultRWHandleSpec

The default behavior for RWHandle.

EHandle

A handle to an executor.

Fifo

An I/O object representing a Fifo.

Interval

An asynchronous interval timer.

JoinHandle

A handle to a future that is owned and polled by the executor.

LocalExecutor

A single-threaded port-based executor for Fuchsia.

MonotonicInstant

A time relative to the executor’s clock.

OnSignals

A future that completes when some set of signals become available on a Handle.

OnSignalsFuture

A future that completes when some set of signals become available on a Handle.

OnStalled

A wrapper for a future who’s steady progress is monitored and will complete with the provided closure if no progress is made before the timeout.

OnTimeout

A wrapper for a future which will complete with a provided closure when a timeout occurs.

RWHandle

A Handle that receives notifications when it is readable/writable.

RawReceiverRegistration

A registration of a PacketReceiver. When dropped, it will automatically deregister the PacketReceiver.

ReceiverRegistration

A registration of a PacketReceiver.

RecvMsg

A future used to receive a message from a channel.

Scope

A scope for managing async tasks. This scope is aborted when dropped.

ScopeHandle

A handle to a scope, which may be used to spawn tasks.

SendExecutor

A multi-threaded port-based executor for Fuchsia. Requires that tasks scheduled on it implement Send so they can be load balanced between worker threads.

Socket

An I/O object representing a Socket.

SpawnableFuture

SpawnableFuture is a boxed future that can be spawned without incurring any more allocations i.e. it doesn’t end up with the double boxing that you end up with if you try and spawn Box<dyn Future>. It can be used in place of BoxFuture although it carries more overhead than BoxFuture, so it shouldn’t be used if it isn’t going to be spawned on a scope. SpawnableFuture implements Future but the future will not be running as a separate task if used this way. If polled and then later spawned, the spawned task will be polled again and any waker recorded when polled prior to spawning will be impotent.

Task

This is the same as a JoinHandle, except that the future will be aborted when the task is dropped.

TaskGroup

Allows the user to spawn multiple Tasks and await them as a unit.

TestExecutor

A single-threaded executor for testing. Exposes additional APIs for manipulating executor state and validating behavior of executed tasks.

Timer

An asynchronous timer.

Enums

ReadableState

State of an object when it is ready for reading.

WritableState

State of an object when it is ready for writing.

Traits

DurationExt

An extension trait to provide after_now on zx::MonotonicDuration.

FifoEntry

Marker trait for types that can be read/written with a Fifo.

PacketReceiver

A trait for handling the arrival of a packet on a zx::Port.

RWHandleSpec

A trait specifying the behavior of RWHandle.

ReadableHandle

A Handle that receives notifications when it is readable.

TimeoutExt

A trait which allows futures to be easily wrapped in a timeout.

WakeupTime

The time when a Timer should wakeup.

WritableHandle

A Handle that receives notifications when it is writable.

Functions

unblock

Offload a blocking function call onto a different thread.

yield_now

Yields execution back to the runtime.

Type Aliases

MonotonicDuration

A duration on the monotonic timeline.

OnSignalsRef

Alias for the common case where OnSignals is used with zx::HandleRef.

Attribute Macros

run

Define an async function that should run to completion on N threads.

run_singlethreaded

Define an async function that should run to completion on a single thread.

run_until_stalled

Define an async function that should complete without stalling.