Asset events & asset load retry plugin

Author: brianreavis

crates/bevy_asset/src/event.rs

@@ -1,8 +1,49 @@
-use crate::{Asset, AssetId};
+use crate::{Asset, AssetId, AssetLoadError, AssetPath, Handle, UntypedAssetId, UntypedHandle};
 use bevy_ecs::event::Event;
 use std::fmt::Debug;
 
-/// Events that occur for a specific [`Asset`], such as "value changed" events and "dependency" events.
+/// An event emitted when a specific [`Asset`] fails to load.
+#[derive(Event, Clone, Debug)]
+pub struct AssetLoadFailedEvent<A: Asset> {
+    pub id: AssetId<A>,
+    /// The original handle returned when the asset load was requested.
+    pub handle: Option<Handle<A>>,
+    /// The asset path that was attempted.
+    pub path: AssetPath<'static>,
+    /// Why the asset failed to load.
+    pub error: AssetLoadError,
+}
+
+impl<A: Asset> AssetLoadFailedEvent<A> {
+    /// Converts this to an "untyped" / "generic-less" asset error event that stores the type information.
+    pub fn untyped(&self) -> UntypedAssetLoadFailedEvent {
+        self.into()
+    }
+}
+
+/// An untyped version of [`AssetLoadFailedEvent`].
+#[derive(Event, Clone, Debug)]
+pub struct UntypedAssetLoadFailedEvent {
+    pub id: UntypedAssetId,
+    pub handle: Option<UntypedHandle>,
+    /// The asset path that was attempted.
+    pub path: AssetPath<'static>,
+    /// Why the asset failed to load.
+    pub error: AssetLoadError,
+}
+
+impl<A: Asset> From<&AssetLoadFailedEvent<A>> for UntypedAssetLoadFailedEvent {
+    fn from(value: &AssetLoadFailedEvent<A>) -> Self {
+        UntypedAssetLoadFailedEvent {
+            id: value.id.untyped(),
+            handle: value.handle.clone().map(|h| h.untyped()),
+            path: value.path.clone(),
+            error: value.error.clone(),
+        }
+    }
+}
+
+/// Events that occur for a specific loaded [`Asset`], such as "value changed" events and "dependency" events.
 #[derive(Event)]
 pub enum AssetEvent<A: Asset> {
     /// Emitted whenever an [`Asset`] is added.

crates/bevy_asset/src/io/mod.rs

@@ -27,20 +27,34 @@ use futures_lite::{ready, Stream};
 use std::{
     path::{Path, PathBuf},
     pin::Pin,
+    sync::Arc,
     task::Poll,
 };
 use thiserror::Error;
 
+use crate::{retry::AssetLoadRetrySettings, UntypedAssetLoadFailedEvent};
+
 /// Errors that occur while loading assets.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 pub enum AssetReaderError {
     /// Path not found.
-    #[error("path not found: {0}")]
+    #[error("Path not found: {0}")]
     NotFound(PathBuf),
 
     /// Encountered an I/O error while loading an asset.
-    #[error("encountered an io error while loading asset: {0}")]
-    Io(#[from] std::io::Error),
+    #[error("Encountered an I/O error while loading asset: {0}")]
+    Io(Arc<std::io::Error>),
+
+    /// The HTTP request completed but returned an unhandled [HTTP response status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
+    /// If the request fails before getting a status code (e.g. request timeout, interrupted connection, etc), expect [`AssetReaderError::Io`].
+    #[error("Encountered HTTP status {0:?} when loading asset")]
+    HttpError(u16),
+}
+
+impl From<std::io::Error> for AssetReaderError {
+    fn from(value: std::io::Error) -> Self {
+        Self::Io(Arc::new(value))
+    }
 }
 
 pub type Reader<'a> = dyn AsyncRead + Unpin + Send + Sync + 'a;
@@ -85,6 +99,14 @@ pub trait AssetReader: Send + Sync + 'static {
             Ok(meta_bytes)
         })
     }
+
+    /// Returns default retry settings to use for a particular failed asset load attempt using this reader.
+    fn get_default_retry_settings(
+        &self,
+        _load_error: &UntypedAssetLoadFailedEvent,
+    ) -> AssetLoadRetrySettings {
+        AssetLoadRetrySettings::no_retries()
+    }
 }
 
 pub type Writer = dyn AsyncWrite + Unpin + Send + Sync;

crates/bevy_asset/src/io/source.rs

@@ -569,22 +569,22 @@ impl AssetSources {
 }
 
 /// An error returned when an [`AssetSource`] does not exist for a given id.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 #[error("Asset Source '{0}' does not exist")]
 pub struct MissingAssetSourceError(AssetSourceId<'static>);
 
 /// An error returned when an [`AssetWriter`] does not exist for a given id.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 #[error("Asset Source '{0}' does not have an AssetWriter.")]
 pub struct MissingAssetWriterError(AssetSourceId<'static>);
 
 /// An error returned when a processed [`AssetReader`] does not exist for a given id.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 #[error("Asset Source '{0}' does not have a processed AssetReader.")]
 pub struct MissingProcessedAssetReaderError(AssetSourceId<'static>);
 
 /// An error returned when a processed [`AssetWriter`] does not exist for a given id.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 #[error("Asset Source '{0}' does not have a processed AssetWriter.")]
 pub struct MissingProcessedAssetWriterError(AssetSourceId<'static>);
 

crates/bevy_asset/src/io/wasm.rs

@@ -1,5 +1,11 @@
-use crate::io::{
-    get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader,
+use crate::{
+    io::{
+        get_meta_path,
+        retry::{IoErrorRetrySettingsProvider, ProvideAssetLoadRetrySettings},
+        AssetLoadRetrySettings, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader,
+        VecReader,
+    },
+    UntypedAssetLoadFailedEvent,
 };
 use bevy_log::error;
 use bevy_utils::BoxedFuture;
@@ -12,15 +18,24 @@ use web_sys::Response;
 /// Reader implementation for loading assets via HTTP in WASM.
 pub struct HttpWasmAssetReader {
     root_path: PathBuf,
+    retry_settings_provider: Box<dyn ProvideAssetLoadRetrySettings>,
 }
 
 impl HttpWasmAssetReader {
     /// Creates a new `WasmAssetReader`. The path provided will be used to build URLs to query for assets.
     pub fn new<P: AsRef<Path>>(path: P) -> Self {
         Self {
             root_path: path.as_ref().to_owned(),
+            retry_settings_provider: Box::new(IoErrorRetrySettingsProvider::from(
+                AssetLoadRetrySettings::network_default(),
+            )),
         }
     }
+    /// Overrides the default retry settings.
+    pub fn with_retry_defaults(mut self, provider: Box<dyn ProvideAssetLoadRetrySettings>) -> Self {
+        self.retry_settings_provider = provider;
+        self
+    }
 }
 
 fn js_value_to_err<'a>(context: &'a str) -> impl FnOnce(JsValue) -> std::io::Error + 'a {
@@ -53,10 +68,7 @@ impl HttpWasmAssetReader {
                 Ok(reader)
             }
             404 => Err(AssetReaderError::NotFound(path)),
-            status => Err(AssetReaderError::Io(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("Encountered unexpected HTTP status {status}"),
-            ))),
+            status => Err(AssetReaderError::HttpError(status as u16)),
         }
     }
 }
@@ -98,4 +110,12 @@ impl AssetReader for HttpWasmAssetReader {
         error!("Reading directories is not supported with the HttpWasmAssetReader");
         Box::pin(async move { Ok(false) })
     }
+
+    fn get_default_retry_settings(
+        &self,
+        load_error: &UntypedAssetLoadFailedEvent,
+    ) -> AssetLoadRetrySettings {
+        self.retry_settings_provider
+            .get_settings(AssetLoadRetrySettings::no_retries(), load_error)
+    }
 }