New v0.4.0 website

cli/src/commands/upload/interface.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use crate::{
     cli::UploadInfo,
     commands::connect::{config::Config, config_option::ConfigOption},
-    manifest::{CompressionOption, DepotManifest, generate_v2_manifest},
+    manifest::{ClosureFactory, CompressionOption, DepotManifest, generate_v2_manifest},
     operator_builder::OperatorBuilder,
 };
 use futures::AsyncWriteExt;
@@ -12,13 +12,13 @@ use opendal::{FuturesAsyncWriter, Operator};
 use tokio_util::compat::{Compat, FuturesAsyncWriteCompatExt};
 
 pub async fn upload(
-    info: &UploadInfo,
+    upload_info: &UploadInfo,
     config: Config,
     name: &Option<String>,
 ) -> anyhow::Result<()> {
-    let game_id = &info.game_id;
-    let path = &info.path;
-    let version_id = &info.version_id;
+    let game_id = upload_info.game_id.clone();
+    let path = upload_info.path.clone();
+    let version_id = upload_info.version_id.clone();
 
     let operator = get_operator(config, name)?;
 
@@ -27,28 +27,30 @@ pub async fn upload(
     info!("Uploading chunks");
 
     let v2_manifest = generate_v2_manifest(
-        Path::new(path),
-        async |id: String| {
-            info!("Uploading chunk id {id}");
-            let writer = operator
-                .writer(&format!("{game_id}/{version_id}/{id}"))
-                .await
-                .unwrap()
-                .into_futures_async_write()
-                .compat_write();
-            writer
-        },
-        |writer: Compat<FuturesAsyncWriter>| async {
-            writer.into_inner().close().await.unwrap();
-        },
+        Path::new(&path),
+        ClosureFactory::new(
+            async move |id: String| {
+                info!("Uploading chunk id {id}");
+                let writer = operator
+                    .writer(&format!("{game_id}/{version_id}/{id}"))
+                    .await
+                    .unwrap()
+                    .into_futures_async_write()
+                    .compat_write();
+                writer
+            },
+            |writer: Compat<FuturesAsyncWriter>| async {
+                writer.into_inner().close().await.unwrap();
+            },
+        ),
     )
     .await?;
 
     info!("Finished uploading chunks");
 
     existing_depot_manifest.append(
-        game_id.to_string(),
-        version_id.to_string(),
+        upload_info.game_id.to_string(),
+        upload_info.version_id.to_string(),
         CompressionOption::None,
     );
     Ok(())

cli/src/main.rs

@@ -1,3 +1,5 @@
+#![feature(async_fn_traits)]
+
 use crate::commands::connect::config::manage_configuration;
 use crate::{
     cli::{Cli, Commands},

cli/src/manifest.rs

@@ -1,8 +1,7 @@
 use std::{collections::HashMap, path::Path};
 
-use droplet_rs::manifest::{
-    Manifest, generate_manifest_rusty, generate_manifest_rusty_v2,
-};
+use async_trait::async_trait;
+use droplet_rs::manifest::{Manifest, ManifestWriterFactory, generate_manifest_rusty};
 use indicatif::{ProgressBar, ProgressStyle};
 use log::info;
 use serde::{Deserialize, Serialize};
@@ -40,11 +39,60 @@ impl DepotManifest {
     }
 }
 
-pub async fn generate_v2_manifest<W, F, CloseF>(dir: &Path, factory: F, closer: CloseF) -> anyhow::Result<Manifest>
+pub struct ClosureFactory<Writer, Factory, Closer>
 where
-    W: AsyncWrite + Unpin,
-    F: AsyncFn(String) -> W,
-    CloseF: AsyncFn(W)
+    Writer: AsyncWrite + Unpin,
+    Factory: AsyncFn(String) -> Writer,
+    Closer: AsyncFn(Writer),
+{
+    writer: Factory,
+    closer: Closer,
+}
+
+#[async_trait]
+impl<
+    W: AsyncWrite + Unpin + Send + Sync,
+    F: AsyncFn(String) -> W + Send + Sync + 'static,
+    C: AsyncFn(W) + Send + Sync,
+> ManifestWriterFactory for ClosureFactory<W, F, C>
+where
+    for<'a> F::CallRefFuture<'a>: Send,
+    for<'b> C::CallRefFuture<'b>: Send,
+{
+    type Writer = W;
+
+    async fn create(&self, id: String) -> anyhow::Result<Self::Writer> {
+        let func = &self.writer;
+        let output = func(id).await;
+        Ok(output)
+    }
+    async fn close(&self, writer: Self::Writer) -> anyhow::Result<()> {
+        let func = &self.closer;
+        func(writer).await;
+        Ok(())
+    }
+}
+
+impl<
+    W: AsyncWrite + Unpin + Send + Sync,
+    F: AsyncFn(String) -> W + Send + Sync + 'static,
+    C: AsyncFn(W) + Sync,
+> ClosureFactory<W, F, C>
+where
+    for<'a> F::CallRefFuture<'a>: Send,
+    for<'b> C::CallRefFuture<'b>: Send,
+{
+    pub fn new(f: F, c: C) -> Self {
+        Self {
+            writer: f,
+            closer: c,
+        }
+    }
+}
+
+pub async fn generate_v2_manifest<Factory>(dir: &Path, factory: Factory) -> anyhow::Result<Manifest>
+where
+    Factory: ManifestWriterFactory,
 {
     let progress_bar = ProgressBar::new(10_000).with_style(
         ProgressStyle::default_bar()
@@ -52,15 +100,15 @@ where
             .unwrap(),
     );
 
-    generate_manifest_rusty_v2(
+    generate_manifest_rusty(
         dir,
         |progress| {
             let progress_int = (progress * 100f32).round() as u64;
             progress_bar.set_position(progress_int);
         },
         |log| progress_bar.suspend(|| info!("{}", log)),
-        factory,
-        closer
+        Some(&factory),
+        None,
     )
     .await
 }