Merge branch 'main' into update-version

studio/src/remote/reader.rs

@@ -1,5 +1,6 @@
 use std::{io::ErrorKind, path::Path, sync::Arc};
 
+use async_compat::Compat;
 use bevy::{
     asset::io::{AssetReader, AssetReaderError, PathStream, Reader, VecReader},
     prelude::*,
@@ -15,6 +16,68 @@ pub struct RemoteAssetReader;
 impl RemoteAssetReader {
     const API_BASE_URL: &'static str = "https://api.fakeyou.com/v1/media_files/file";
     const BUCKET_BASE_URL: &'static str = "https://storage.googleapis.com/vocodes-public";
+
+    async fn load<'a>(&'a self, path: &'a Path) -> Result<Box<Reader<'a>>, AssetReaderError> {
+        let token = path
+            .ext_file_prefix()
+            .ok_or_else(|| {
+                AssetReaderError::Io(std::io::Error::new(
+                    ErrorKind::Other,
+                    format!("Failed to parse token from '{path:?}'"),
+                ))
+            })?
+            .to_str()
+            .unwrap();
+
+        info!("Loading asset from media token: '{token}'");
+
+        let response = reqwest::get(format!("{}/{token}", &Self::API_BASE_URL))
+            .await
+            .map_err(IntoError::<AssetReaderError>::into)?;
+
+        let response = match response.status() {
+            StatusCode::OK => response
+                .json::<GetMediaFileSuccessResponse>()
+                .await
+                .map_err(IntoError::<AssetReaderError>::into),
+            other => Err(AssetReaderError::Io(std::io::Error::new(
+                ErrorKind::Other,
+                format!("Status Code from endpoint: {other}"),
+            ))),
+        }?;
+
+        let url = format!(
+            "{}{}",
+            &Self::BUCKET_BASE_URL,
+            &response.media_file.public_bucket_path
+        );
+
+        let response = reqwest::get(url)
+            .await
+            .map_err(IntoError::<AssetReaderError>::into)?;
+
+        let bytes = match response.status() {
+            // TODO: This is not thread-safe, but some variation of this
+            //       would be better than the current solution once Bevy
+            //       WASM becomes multi-threaded:
+            // StatusCode::OK => Ok(response.bytes_stream().map(|result| {
+            //     result.map_err(|err| std::io::Error::new(ErrorKind::Other, format!("{err}")))
+            // })),
+            StatusCode::OK => Ok(response
+                .bytes()
+                .await
+                .map_err(IntoError::<AssetReaderError>::into)?
+                .into_iter()
+                .collect::<Vec<_>>()),
+            other => Err(AssetReaderError::Io(std::io::Error::new(
+                ErrorKind::Other,
+                format!("Status Code from bucket URL: {other}"),
+            ))),
+        }?;
+
+        let reader: Box<Reader> = Box::new(VecReader::new(bytes));
+        Ok(reader)
+    }
 }
 
 impl AssetReader for RemoteAssetReader {
@@ -22,67 +85,16 @@ impl AssetReader for RemoteAssetReader {
         &'a self,
         path: &'a Path,
     ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
-        Box::pin(async move {
-            let token = path
-                .ext_file_prefix()
-                .ok_or_else(|| {
-                    AssetReaderError::Io(Arc::new(std::io::Error::new(
-                        ErrorKind::Other,
-                        format!("Failed to parse token from '{path:?}'"),
-                    )))
-                })?
-                .to_str()
-                .unwrap();
-
-            info!("Loading asset from media token: '{token}'");
-
-            let response = reqwest::get(format!("{}/{token}", &Self::API_BASE_URL))
-                .await
-                .map_err(IntoError::<AssetReaderError>::into)?;
-
-            let response = match response.status() {
-                StatusCode::OK => response
-                    .json::<GetMediaFileSuccessResponse>()
-                    .await
-                    .map_err(IntoError::<AssetReaderError>::into),
-                other => Err(AssetReaderError::Io(Arc::new(std::io::Error::new(
-                    ErrorKind::Other,
-                    format!("Status Code from endpoint: {other}"),
-                )))),
-            }?;
-
-            let url = format!(
-                "{}{}",
-                &Self::BUCKET_BASE_URL,
-                &response.media_file.public_bucket_path
-            );
-
-            let response = reqwest::get(url)
-                .await
-                .map_err(IntoError::<AssetReaderError>::into)?;
-
-            let bytes = match response.status() {
-                // TODO: This is not thread-safe, but some variation of this
-                //       would be better than the current solution once Bevy
-                //       WASM becomes multi-threaded:
-                // StatusCode::OK => Ok(response.bytes_stream().map(|result| {
-                //     result.map_err(|err| std::io::Error::new(ErrorKind::Other, format!("{err}")))
-                // })),
-                StatusCode::OK => Ok(response
-                    .bytes()
-                    .await
-                    .map_err(IntoError::<AssetReaderError>::into)?
-                    .into_iter()
-                    .collect::<Vec<_>>()),
-                other => Err(AssetReaderError::Io(Arc::new(std::io::Error::new(
-                    ErrorKind::Other,
-                    format!("Status Code from bucket URL: {other}"),
-                )))),
-            }?;
-
-            let reader: Box<Reader> = Box::new(VecReader::new(bytes));
-            Ok(reader)
-        })
+        let unboxed = async move { self.load(path).await };
+        if cfg!(not(feature = "wasm")) {
+            info!("wasm mode not detected");
+            // NB: Headless mode (server rendering) is running without a Tokio runtime.
+            // The reqwest HTTP client requires async-compat to function at runtime.
+            Box::pin(Compat::new(unboxed))
+        } else {
+            info!("wasm mode");
+            Box::pin(unboxed)
+        }
     }
 
     fn read_meta<'a>(