tweak: generate temp filenames ourselves

Author: DevBlocky

Cargo.lock

@@ -13,18 +13,17 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tempfile = "3.2.0"
 sled = "0.34.6"
 hex = "0.4.3"
 md5 = "0.7.0"
+rand = {version = "0.8.3", features = ["small_rng", "getrandom"], default-features = false}
 bson = {version = "1.2.2", features = ["u2i"]}
 serde = {version = "1.0.125", features = ["derive"]}
 tokio = {version = "1.5.0", features = ["rt", "fs", "io-util"]}
 
 [dev-dependencies]
 tokio = {version = "1.5.0", features = ["full"]}
 criterion = {version = "0.3.4", features = ["async_tokio", "html_reports"]}
-rand = {version = "0.8.3", features = ["small_rng"], default-features = false}
 
 [lib]
 path = "src/lib.rs"

Cargo.toml

@@ -3,6 +3,20 @@ use std::io;
 use std::path;
 use tokio::fs as afs;
 
+/// Creates a writeable and persistent temporary file in the path provided, returning the path and
+/// file handle.
+async fn tempfile(dir: &path::Path) -> Result<(afs::File, path::PathBuf)> {
+    let tmppath = crate::tmp::tmppath_in(dir);
+    let tmp = afs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&tmppath)
+        .await
+        .map_err(ForcepError::Io)?;
+    Ok((tmp, tmppath))
+}
+
 /// The main component of `forceps`, acts as the API for interacting with the on-disk API.
 ///
 /// This structure exposes `read`, `write`, and misc metadata operations. `read` and `write` are
@@ -43,6 +57,7 @@ pub struct CacheBuilder {
     path: path::PathBuf,
 }
 
+
 impl Cache {
     /// Creates a new Cache instance based on the CacheBuilder
     async fn new(builder: CacheBuilder) -> Result<Self> {
@@ -78,29 +93,6 @@ impl Cache {
         buf
     }
 
-    /// Creates a temporary file in the `self.path` directory of the cache, returning the file
-    /// handle and the path of the file created.
-    async fn open_tempfile(&self) -> Result<(afs::File, path::PathBuf)> {
-        let tmp_in = self.path.clone();
-
-        // spawn a blocking task to create the temporary file
-        tokio::task::spawn_blocking(move || {
-            // create a new named temporary file and persist it to capture the file handle and path
-            tempfile::NamedTempFile::new_in(&tmp_in)
-                .map_err(ForcepError::Io)
-                .and_then(|x| x.keep().map_err(|e| ForcepError::Io(e.into())))
-                .map(|(file, path)| (afs::File::from_std(file), path))
-        })
-        .await
-        .map_err(|_| {
-            ForcepError::Io(io::Error::new(
-                io::ErrorKind::Other,
-                "cannot join blocking task",
-            ))
-        })
-        .and_then(|x| x)
-    }
-
     /// Reads an entry from the database, returning a vector of bytes that represent the entry.
     ///
     /// # Not Found
@@ -175,7 +167,7 @@ impl Cache {
         let key = key.as_ref();
         let value = value.as_ref();
 
-        let (tmp, tmp_path) = self.open_tempfile().await?;
+        let (tmp, tmp_path) = tempfile(&self.path).await?;
         // write all data to a temporary file
         {
             let mut writer = tokio::io::BufWriter::new(tmp);

src/cache.rs

@@ -83,6 +83,8 @@ impl std::fmt::Display for ForcepError {
 }
 impl std::error::Error for ForcepError {}
 
+mod tmp;
+
 mod cache;
 pub use cache::{Cache, CacheBuilder};
 

src/lib.rs

@@ -0,0 +1,40 @@
+use rand::{
+    prelude::*,
+    distributions::Alphanumeric
+};
+use std::cell::UnsafeCell;
+use std::path;
+use std::ffi::{OsString, OsStr};
+use std::str;
+
+std::thread_local! {
+    static RNG: UnsafeCell<SmallRng> = UnsafeCell::new(SmallRng::from_entropy());
+}
+
+/// Reimplementation of [this][tmpfile]. Licensed under Apache license
+///
+/// [tmpfile]: https://github.com/Stebalien/tempfile/blob/c361acc1213605eb26be0ad6de4c0f29cb7491f0/src/util.rs#L17
+fn tmpname(prefix: &OsStr, rand_len: usize) -> OsString {
+    let mut buf = OsString::with_capacity(prefix.len() + rand_len);
+    buf.push(prefix);
+
+    // Push each character in one-by-one. Unfortunately, this is the only
+    // safe(ish) simple way to do this without allocating a temporary
+    // String/Vec.
+    RNG.with(|rng| unsafe {
+        (&mut *rng.get())
+            .sample_iter(&Alphanumeric)
+            .take(rand_len)
+            .for_each(|b| buf.push(str::from_utf8_unchecked(&[b as u8])))
+    });
+    buf
+}
+
+/// Creates a randomized path in a directory that can be used as a temporary file
+pub(crate) fn tmppath_in(dir: &path::Path) -> path::PathBuf {
+    const LEN: usize = 10;
+    let mut buf = path::PathBuf::new();
+    buf.push(dir);
+    buf.push(&tmpname(OsStr::new("tmp"), LEN));
+    buf
+}