mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-14 00:00:12 +02:00
Carl Lerche
08e20fcf6a
Provides a thread pool dedicated to running blocking operations (#588) and update `tokio-fs` to use this pool. In an effort to make incremental progress, this is an initial step towards a final solution. First, it provides a very basic pool implementation with the intend that the pool will be replaced before the final release. Second, it updates `tokio-fs` to always use this blocking pool instead of conditionally using `threadpool::blocking`. Issue #588 contains additional discussion around potential improvements to the "blocking for all" strategy. The implementation provided here builds on work started in #954 and continued in #1045. The general idea is th same as #1045, but the PR improves on some of the details: * The number of explicit operations tracked by `File` is reduced only to the ones that could interact. All other ops are spawned on the blocking pool without being tracked by the `File` instance. * The `seek` implementation is not backed by a trait and `poll_seek` function. This avoids the question of how to model non-blocking seeks on top of a blocking file. In this patch, `seek` is represented as an `async fn`. If the associated future is dropped before the caller observes the return value, we make no effort to define the state in which the file ends up.
29 lines
694 B
Rust
29 lines
694 B
Rust
use crate::asyncify;
|
|
|
|
use std::{io, path::Path};
|
|
|
|
/// Creates a future that will open a file for writing and write the entire
|
|
/// contents of `contents` to it.
|
|
///
|
|
/// This is the async equivalent of `std::fs::write`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```no_run
|
|
/// use tokio::fs;
|
|
///
|
|
/// # async fn dox() -> std::io::Result<()> {
|
|
/// fs::write("foo.txt", b"Hello world!").await?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub async fn write<P, C: AsRef<[u8]> + Unpin>(path: P, contents: C) -> io::Result<()>
|
|
where
|
|
P: AsRef<Path> + Send + Unpin + 'static,
|
|
{
|
|
let path = path.as_ref().to_owned();
|
|
let contents = contents.as_ref().to_owned();
|
|
|
|
asyncify(move || std::fs::write(path, contents)).await
|
|
}
|