use crate::common::fs instead of tokio::fs

Convert tokio::fs call sites to use crate::common::fs for better error
messages. Also fix a case of blocking io.

twoliter/src/cmd/debug.rs

@@ -1,9 +1,9 @@
+use crate::common::fs;
 use crate::tools::install_tools;
-use anyhow::{Context, Result};
+use anyhow::Result;
 use clap::Parser;
 use std::env;
 use std::path::PathBuf;
-use tokio::fs;
 use uuid::Uuid;
 
 #[derive(Debug, Clone, Parser)]
@@ -49,9 +49,7 @@ impl CheckToolArgs {
             .install_dir
             .clone()
             .unwrap_or_else(|| env::temp_dir().join(unique_name()));
-        fs::create_dir_all(&dir)
-            .await
-            .context(format!("Unable to create directory '{}'", dir.display()))?;
+        fs::create_dir_all(&dir).await?;
         install_tools(&dir).await?;
         println!("{}", dir.display());
         Ok(())

twoliter/src/cmd/make.rs

@@ -1,10 +1,10 @@
 use crate::cargo_make::CargoMake;
+use crate::common::fs;
 use crate::project::{self};
 use crate::tools::install_tools;
 use anyhow::Result;
 use clap::Parser;
 use std::path::PathBuf;
-use tokio::fs;
 
 /// Run a cargo make command in Twoliter's build environment. Known Makefile.toml environment
 /// variables will be passed-through to the cargo make invocation.

twoliter/src/project.rs

@@ -1,3 +1,4 @@
+use crate::common::fs;
 use crate::docker::ImageArchUri;
 use crate::schema_version::SchemaVersion;
 use anyhow::{ensure, Context, Result};
@@ -7,7 +8,6 @@ use non_empty_string::NonEmptyString;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha512};
 use std::path::{Path, PathBuf};
-use tokio::fs;
 use toml::Table;
 
 /// Common functionality in commands, if the user gave a path to the `Twoliter.toml` file,
@@ -241,9 +241,9 @@ impl UnvalidatedProject {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::common::fs;
     use crate::test::data_dir;
     use tempfile::TempDir;
-    use tokio::fs;
 
     /// Ensure that `Twoliter.toml` can be deserialized.
     #[tokio::test]
@@ -341,18 +341,10 @@ mod test {
         let release_toml_to = p.join("Release.toml");
         fs::copy(&twoliter_toml_from, &twoliter_toml_to)
             .await
-            .expect(&format!(
-                "Unable to copy {} to {}",
-                twoliter_toml_from.display(),
-                twoliter_toml_to.display()
-            ));
+            .unwrap();
         fs::copy(&release_toml_from, &release_toml_to)
             .await
-            .expect(&format!(
-                "Unable to copy {} to {}",
-                release_toml_from.display(),
-                release_toml_to.display()
-            ));
+            .unwrap();
         let result = Project::find_and_load(&p).await;
         assert!(
             result.is_err(),
@@ -372,18 +364,10 @@ mod test {
         let release_toml_to = p.join("Release.toml");
         fs::copy(&twoliter_toml_from, &twoliter_toml_to)
             .await
-            .expect(&format!(
-                "Unable to copy {} to {}",
-                twoliter_toml_from.display(),
-                twoliter_toml_to.display()
-            ));
+            .unwrap();
         fs::copy(&release_toml_from, &release_toml_to)
             .await
-            .expect(&format!(
-                "Unable to copy {} to {}",
-                release_toml_from.display(),
-                release_toml_to.display()
-            ));
+            .unwrap();
 
         // The project should load because Release.toml and Twoliter.toml versions match.
         Project::find_and_load(&p).await.unwrap();

twoliter/src/tools.rs

@@ -1,11 +1,13 @@
+use crate::common::fs;
 use anyhow::{Context, Result};
 use filetime::{set_file_handle_times, set_file_mtime, FileTime};
 use flate2::read::ZlibDecoder;
 use log::debug;
 use std::path::Path;
 use tar::Archive;
-use tokio::fs;
+use tokio::fs::OpenOptions;
 use tokio::io::AsyncWriteExt;
+use tokio::runtime::Handle;
 
 const TAR_GZ_DATA: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/tools.tar.gz"));
 const BOTTLEROCKET_VARIANT: &[u8] =
@@ -49,7 +51,7 @@ pub(crate) async fn install_tools(tools_dir: impl AsRef<Path>) -> Result<()> {
 
 async fn write_bin(name: &str, data: &[u8], dir: impl AsRef<Path>, mtime: FileTime) -> Result<()> {
     let path = dir.as_ref().join(name);
-    let mut f = fs::OpenOptions::new()
+    let mut f = OpenOptions::new()
         .create(true)
         .read(false)
         .write(true)
@@ -65,9 +67,15 @@ async fn write_bin(name: &str, data: &[u8], dir: impl AsRef<Path>, mtime: FileTi
         .context(format!("Unable to finalize '{}'", path.display()))?;
 
     let f = f.into_std().await;
-    set_file_handle_times(&f, None, Some(mtime))
-        .context(format!("Unable to set mtime for '{}'", path.display()))?;
-    Ok(())
+    let rt = Handle::current();
+    rt.spawn_blocking(move || {
+        set_file_handle_times(&f, None, Some(mtime))
+            .context(format!("Unable to set mtime for '{}'", path.display()))
+    })
+    .await
+    .context(format!(
+        "Unable to run and join async task for reading handle time"
+    ))?
 }
 
 async fn unpack_tarball(tools_dir: impl AsRef<Path>) -> Result<()> {