Published TempDirectory Resrouce

Allows configuration of the temp directory after startup, and the retrieval of the `Path` for 3rd party use.

Author: bushrat011899

crates/bevy_asset/src/lib.rs

@@ -51,6 +51,9 @@ pub use path::*;
 pub use reflect::*;
 pub use server::*;
 
+#[cfg(not(target_arch = "wasm32"))]
+pub use temp::TempDirectory;
+
 /// Rusty Object Notation, a crate used to serialize and deserialize bevy assets.
 pub use ron;
 

crates/bevy_asset/src/temp.rs

@@ -4,14 +4,55 @@ use std::{
 };
 
 use bevy_ecs::{system::Resource, world::World};
+use bevy_utils::Duration;
 
-use crate::io::AssetSourceBuilder;
+use crate::io::{
+    AssetReader, AssetSource, AssetSourceBuilder, AssetSourceEvent, AssetWatcher, AssetWriter,
+    ErasedAssetReader, ErasedAssetWriter,
+};
+
+/// A [resource](`Resource`) providing access to the temporary directory used by the `temp://`
+/// [asset source](`AssetSource`).
+#[derive(Resource)]
+pub struct TempDirectory {
+    directory: TempDirectoryKind,
+}
+
+impl TempDirectory {
+    /// Try to create a new [`TempDirectory`] resource, which uses a randomly created
+    /// directory in the user's temporary directory. This can fail if the platform does not
+    /// provide an appropriate temporary directory, or the directory itself could not be created.
+    pub fn new_transient() -> std::io::Result<Self> {
+        let directory = TempDirectoryKind::new_transient()?;
+
+        Ok(Self { directory })
+    }
+
+    /// Create a new [`TempDirectory`] resource, which uses a provided directory to store temporary
+    /// assets. It is assumed this directory already exists, and it will _not_ be deleted on exit.
+    pub fn new_persistent(path: impl Into<PathBuf>) -> Self {
+        let directory = TempDirectoryKind::new_persistent(path);
+
+        Self { directory }
+    }
+
+    /// Get the [`Path`] to the directory used for temporary assets.
+    pub fn path(&self) -> &Path {
+        self.directory.path()
+    }
+
+    /// Persist the current temporary asset directory after application exit.
+    pub fn persist(&mut self) -> &mut Self {
+        self.directory.persist();
+
+        self
+    }
+}
 
 /// Private resource to store the temporary directory used by `temp://`.
 /// Kept private as it should only be removed on application exit.
-#[derive(Resource)]
-enum TempDirectory {
-    /// Uses [`TempDir`](tempfile::TempDir)'s drop behaviour to delete the directory.
+enum TempDirectoryKind {
+    /// Uses [`TempDir`](tempfile::TempDir)'s drop behavior to delete the directory.
     /// Note that this is not _guaranteed_ to succeed, so it is possible to leak files from this
     /// option until the underlying OS cleans temporary directories. For secure files, consider using
     /// [`tempfile`](tempfile::tempfile) directly.
@@ -21,13 +62,37 @@ enum TempDirectory {
     Persist(PathBuf),
 }
 
-impl TempDirectory {
+impl TempDirectoryKind {
+    fn new_transient() -> std::io::Result<Self> {
+        let directory = tempfile::TempDir::with_prefix("bevy_")?;
+        Ok(Self::Delete(directory))
+    }
+
+    fn new_persistent(path: impl Into<PathBuf>) -> Self {
+        Self::Persist(path.into())
+    }
+
     fn path(&self) -> &Path {
         match self {
-            TempDirectory::Delete(x) => x.path(),
-            TempDirectory::Persist(x) => x.as_ref(),
+            Self::Delete(x) => x.as_ref(),
+            Self::Persist(x) => x.as_ref(),
         }
     }
+
+    fn persist(&mut self) -> &mut Self {
+        let mut swap = Self::Persist(PathBuf::new());
+
+        std::mem::swap(self, &mut swap);
+
+        let new = match swap {
+            Self::Delete(x) => Self::Persist(x.into_path()),
+            x @ Self::Persist(_) => x,
+        };
+
+        *self = new;
+
+        self
+    }
 }
 
 pub(crate) fn get_temp_source(
@@ -37,20 +102,177 @@ pub(crate) fn get_temp_source(
     let temp_dir = match world.remove_resource::<TempDirectory>() {
         Some(resource) => resource,
         None => match temporary_file_path {
-            Some(path) => TempDirectory::Persist(path.into()),
-            None => TempDirectory::Delete(tempfile::TempDir::with_prefix("bevy")?),
+            Some(path) => TempDirectory::new_persistent(path),
+            None => TempDirectory::new_transient()?,
         },
     };
 
-    let path = temp_dir
+    let path: &str = temp_dir
         .path()
         .as_os_str()
         .try_into()
         .map_err(|error| Error::new(ErrorKind::InvalidData, error))?;
 
-    let source = AssetSourceBuilder::platform_default(path, None);
+    let path = path.to_owned();
+    let debounce = Duration::from_millis(300);
+
+    let source = AssetSourceBuilder::default()
+        .with_reader(TempAssetReader::get_default(path.clone()))
+        .with_writer(TempAssetWriter::get_default(path.clone()))
+        .with_watcher(TempAssetWatcher::get_default(path.clone(), debounce))
+        .with_watch_warning(TempAssetWatcher::get_default_watch_warning());
 
     world.insert_resource(temp_dir);
 
     Ok(source)
 }
+
+struct TempAssetReader {
+    inner: Box<dyn ErasedAssetReader>,
+}
+
+impl TempAssetReader {
+    fn get_default(path: String) -> impl FnMut() -> Box<dyn ErasedAssetReader> + Send + Sync {
+        move || {
+            let mut getter = AssetSource::get_default_reader(path.clone());
+            let inner = getter();
+
+            Box::new(Self { inner })
+        }
+    }
+}
+
+impl AssetReader for TempAssetReader {
+    async fn read<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<Box<crate::io::Reader<'a>>, crate::io::AssetReaderError> {
+        self.inner.read(path).await
+    }
+
+    async fn read_meta<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<Box<crate::io::Reader<'a>>, crate::io::AssetReaderError> {
+        self.inner.read_meta(path).await
+    }
+
+    async fn read_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<Box<crate::io::PathStream>, crate::io::AssetReaderError> {
+        self.inner.read_directory(path).await
+    }
+
+    async fn is_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<bool, crate::io::AssetReaderError> {
+        self.inner.is_directory(path).await
+    }
+}
+
+struct TempAssetWriter {
+    inner: Box<dyn ErasedAssetWriter>,
+}
+
+impl TempAssetWriter {
+    fn get_default(
+        path: String,
+    ) -> impl FnMut(bool) -> Option<Box<dyn ErasedAssetWriter>> + Send + Sync {
+        move |condition| {
+            let mut getter = AssetSource::get_default_writer(path.clone());
+            let inner = getter(condition)?;
+
+            Some(Box::new(Self { inner }))
+        }
+    }
+}
+
+impl AssetWriter for TempAssetWriter {
+    async fn write<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<Box<crate::io::Writer>, crate::io::AssetWriterError> {
+        self.inner.write(path).await
+    }
+
+    async fn write_meta<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<Box<crate::io::Writer>, crate::io::AssetWriterError> {
+        self.inner.write_meta(path).await
+    }
+
+    async fn remove<'a>(&'a self, path: &'a Path) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.remove(path).await
+    }
+
+    async fn remove_meta<'a>(&'a self, path: &'a Path) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.remove_meta(path).await
+    }
+
+    async fn rename<'a>(
+        &'a self,
+        old_path: &'a Path,
+        new_path: &'a Path,
+    ) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.rename(old_path, new_path).await
+    }
+
+    async fn rename_meta<'a>(
+        &'a self,
+        old_path: &'a Path,
+        new_path: &'a Path,
+    ) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.rename_meta(old_path, new_path).await
+    }
+
+    async fn remove_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.remove_directory(path).await
+    }
+
+    async fn remove_empty_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.remove_empty_directory(path).await
+    }
+
+    async fn remove_assets_in_directory<'a>(
+        &'a self,
+        path: &'a Path,
+    ) -> Result<(), crate::io::AssetWriterError> {
+        self.inner.remove_assets_in_directory(path).await
+    }
+}
+
+struct TempAssetWatcher {
+    _inner: Box<dyn AssetWatcher>,
+}
+
+impl TempAssetWatcher {
+    fn get_default(
+        path: String,
+        file_debounce_wait_time: Duration,
+    ) -> impl FnMut(crossbeam_channel::Sender<AssetSourceEvent>) -> Option<Box<dyn AssetWatcher>>
+           + Send
+           + Sync {
+        move |channel| {
+            let mut getter =
+                AssetSource::get_default_watcher(path.clone(), file_debounce_wait_time);
+            let _inner = getter(channel)?;
+
+            Some(Box::new(Self { _inner }))
+        }
+    }
+
+    fn get_default_watch_warning() -> &'static str {
+        AssetSource::get_default_watch_warning()
+    }
+}
+
+impl AssetWatcher for TempAssetWatcher {}

examples/asset/temp_asset.rs

@@ -5,7 +5,7 @@
 use bevy::{
     asset::{
         saver::{AssetSaver, ErasedAssetSaver},
-        AssetPath, ErasedLoadedAsset, LoadedAsset,
+        AssetPath, ErasedLoadedAsset, LoadedAsset, TempDirectory,
     },
     prelude::*,
     tasks::{block_on, IoTaskPool, Task},
@@ -25,7 +25,11 @@ fn main() {
 }
 
 /// Attempt to save an asset to the temporary asset source.
-fn save_temp_asset(assets: Res<AssetServer>, mut commands: Commands) {
+fn save_temp_asset(
+    assets: Res<AssetServer>,
+    mut commands: Commands,
+    temp_directory: Res<TempDirectory>,
+) {
     // This is the asset we will attempt to save.
     let my_text_asset = TextAsset("Hello World!".to_owned());
 
@@ -34,6 +38,10 @@ fn save_temp_asset(assets: Res<AssetServer>, mut commands: Commands) {
     let path = AssetPath::from("temp://message.txt").into_owned();
     let server = assets.clone();
 
+    // We use Bevy's IoTaskPool to run the saving task asynchronously. This ensures
+    // our application doesn't block during the (potentially lengthy!) saving process.
+    // In this example, the asset is small so the blocking time will be short, but
+    // that wont always be the case, especially for large assets.
     let task = IoTaskPool::get().spawn(async move {
         save_asset(my_text_asset, path, server, TextSaver)
             .await
@@ -43,6 +51,13 @@ fn save_temp_asset(assets: Res<AssetServer>, mut commands: Commands) {
     // To ensure the task completes before we try loading, we will manually poll this task
     // so we can react to its completion.
     commands.spawn(SavingTask(task));
+
+    // You can check the logged path to see the temporary directory yourself. Note
+    // that the directory will be deleted once this example quits.
+    info!(
+        "Temporary Assets will be saved in {:?}",
+        temp_directory.path()
+    );
 }
 
 /// Poll the save tasks until completion, and then start loading our temporary text asset.
@@ -52,7 +67,9 @@ fn wait_until_temp_saved(
     mut commands: Commands,
 ) {
     for (entity, mut task) in tasks.iter_mut() {
+        // Check our SavingTask to see if it's done...
         if let Some(()) = block_on(future::poll_once(&mut task.0)) {
+            // ...and if so, load the temporary asset!
             commands.insert_resource(MyTempText {
                 text: assets.load("temp://message.txt"),
             });