Struct TokioRuntime 

pub struct TokioRuntime;

Available on crate feature tokio-runtime only.

The Runtime implementation backed by the tokio crate. Since tokio heavily utilizes thread-local storage, this struct is zero-sized and doesn’t store anything.

Trait Implementations

impl Clone for TokioRuntime

fn clone(&self) -> TokioRuntime

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Runtime for TokioRuntime

type Task<O: Send + 'static> = TokioRuntimeTask<O>

The RuntimeTask implementation used by this Runtime.

type TimeoutError = Elapsed

The error this Runtime yields when a future times out in a controlled manner.

type File = Compat<File>

The I/O object representing an opened asynchronously readable file within this Runtime.

type AsyncFd = TokioRuntimeAsyncFd

The RuntimeAsyncFd implementation used by this Runtime.

type Child = TokioRuntimeChild

The RuntimeChild implementation used by this Runtime.

type SocketBackend = TokioBackend

Available on crate feature vmm-process only.

The hyper_client_sockets::Backend of this Runtime, used by fctools to establish connections over Unix or Firecracker sockets.

fn spawn_task<F>(&self, future: F) -> Self::Task<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawn a static Send future returning a static Send type onto this Runtime and return its joinable task.

fn timeout<F>( &self, duration: Duration, future: F, ) -> impl Future<Output = Result<F::Output, Self::TimeoutError>> + Send

where F: Future + Send, F::Output: Send,

Await a Send future returning a Send type, cancelling it after the giving Duration and returning a timeout error.

fn fs_exists( &self, path: &Path, ) -> impl Future<Output = Result<bool, Error>> + Send

Check if the given Path exists on the filesystem.

fn fs_remove_file( &self, path: &Path, ) -> impl Future<Output = Result<(), Error>> + Send

Remove the given Path as a file from the filesystem.

fn fs_create_dir_all( &self, path: &Path, ) -> impl Future<Output = Result<(), Error>> + Send

Recursively create a directory tree at the given Path on the filesystem.

async fn fs_create_file(&self, path: &Path) -> Result<(), Error>

Create a file at the given Path on the filesystem.

fn fs_write( &self, path: &Path, content: String, ) -> impl Future<Output = Result<(), Error>> + Send

Write the provided String blob to the given Path on the filesystem.

fn fs_read_to_string( &self, path: &Path, ) -> impl Future<Output = Result<String, Error>> + Send

Read the contents of the file at the given Path on the filesystem to a String blob.

fn fs_rename( &self, source_path: &Path, destination_path: &Path, ) -> impl Future<Output = Result<(), Error>> + Send

Rename the provided source Path to the provided destination Path on the filesystem.

fn fs_remove_dir_all( &self, path: &Path, ) -> impl Future<Output = Result<(), Error>> + Send

Recursively remove the directory and its contents at the given Path on the filesystem.

async fn fs_copy( &self, source_path: &Path, destination_path: &Path, ) -> Result<(), Error>

Copy the file at the source Path on the filesystem to the destination Path.

async fn fs_chown_all( &self, path: &Path, uid: u32, gid: u32, ) -> Result<(), Error>

Recursively change the ownership of the given Path on the filesystem to the given PAM UID and GID.

fn fs_hard_link( &self, source_path: &Path, destination_path: &Path, ) -> impl Future<Output = Result<(), Error>> + Send

Hard-link the given source Path on the filesystem to the given destination Path.

async fn fs_open_file_for_read(&self, path: &Path) -> Result<Self::File, Error>

Open the file at the given Path on the filesystem in read-only mode, returning an I/O object used for asynchronously reading its contents.

fn create_async_fd(&self, fd: OwnedFd) -> Result<Self::AsyncFd, Error>

Create an asynchronous file descriptor from the given OwnedFd, tying it to this Runtime’s I/O reactor.

fn spawn_process( &self, program: &OsStr, args: &[OsString], stdout: bool, stderr: bool, stdin: bool, ) -> Result<Self::Child, Error>

Spawn a child process asynchronously on this Runtime, using the given program, arguments and flags determining whether the stdout, stderr and stdin pipes are nulled or piped.

fn run_process( &self, program: &OsStr, args: &[OsString], stdout: bool, stderr: bool, ) -> impl Future<Output = Result<Output, Error>> + Send

Run a child process asynchronously on this Runtime until completion, using the given program, arguments and flags determining whether the stdout and stderr pipes are nulled or piped.