chore: Mostly finished s3 config

cli/src/commands/upload/interface.rs

@@ -2,33 +2,39 @@ use std::path::Path;
 
 use crate::{
     cli::UploadInfo,
-    commands::upload::{uploadable::Uploadable, void::VoidUploadable},
+    commands::upload::{s3::S3, uploadable::Uploadable},
+    config::Config,
     manifest::generate_manifest,
 };
 use log::info;
 
-pub async fn upload(info: &UploadInfo) -> anyhow::Result<()> {
+pub async fn upload(info: &UploadInfo, config: Config) -> anyhow::Result<()> {
     let game_id = &info.game_id;
     let path = &info.path;
     let version_id = &info.version_id;
 
     let manifest = generate_manifest(&Path::new(path)).await?;
     let mut uploader: Box<dyn Uploadable> = match info.upload_style {
-        crate::cli::UploadStyle::S3 => Box::new(VoidUploadable::new()),
-        crate::cli::UploadStyle::Nginx => Box::new(VoidUploadable::new()),
+        crate::cli::UploadStyle::S3 => Box::new(S3::new(
+            config
+                .get_active_s3()
+                .ok_or(anyhow::Error::msg("Could not get active S3 value"))?,
+        )?),
     };
     info!("Uploading chunks");
     for (id, data) in &manifest.chunks {
         info!("Uploading chunk id {id}");
-        uploader.upload_chunk(game_id, version_id, id, data)?;
+        uploader.upload_chunk(game_id, version_id, id, data).await?;
     }
     info!("Finished uploading chunks");
 
     info!("Uploading manifest");
-    uploader.upload_manifest(manifest, game_id, version_id)?;
+    uploader
+        .upload_manifest(manifest, game_id, version_id)
+        .await?;
 
     info!("Uploading speedtest");
-    uploader.upload_speedtest(game_id, version_id)?;
+    uploader.upload_speedtest().await?;
 
     Ok(())
 }

cli/src/commands/upload/mod.rs

@@ -1,4 +1,5 @@
 pub mod interface;
 pub mod s3;
 pub mod uploadable;
-pub mod void;
+pub mod void;
+pub mod speedtest;

cli/src/commands/upload/s3.rs

@@ -1,10 +1,29 @@
+use crate::{
+    commands::upload::{
+        speedtest::{SPEEDTEST_PATH, Speedtest},
+        uploadable::Uploadable,
+    },
+    config::S3Config,
+};
+use async_trait::async_trait;
 use droplet_rs::manifest::{ChunkData, Manifest};
+use s3::{Bucket, creds::Credentials};
+use serde_json::json;
+use std::{ops::Deref, path::PathBuf};
 
-use crate::commands::upload::uploadable::Uploadable;
-
-pub type S3 = aws_sdk_s3::Client;
+pub struct S3 {
+    bucket: s3::Bucket,
+}
+impl S3 {
+    pub fn new(config: &S3Config) -> anyhow::Result<Self> {
+        Ok(Self {
+            bucket: config.generate_bucket()?,
+        })
+    }
+}
+#[async_trait]
 impl Uploadable for S3 {
-    fn upload_chunk(
+    async fn upload_chunk(
         &mut self,
         id: &String,
         version: &String,
@@ -13,16 +32,39 @@ impl Uploadable for S3 {
     ) -> anyhow::Result<()> {
         todo!()
     }
-    fn upload_speedtest(&mut self, game_id: &String, version_id: &String) -> anyhow::Result<()> {
-        todo!()
+    async fn upload_speedtest(&mut self) -> anyhow::Result<()> {
+        if self.object_exists(SPEEDTEST_PATH).await? {
+            return Ok(());
+        }
+        let mut speedtest = Speedtest::new();
+        self.put_object_stream(&mut speedtest, SPEEDTEST_PATH)
+            .await?;
+        Ok(())
     }
 
-    fn upload_manifest(
+    async fn upload_manifest(
         &mut self,
         manifest: Manifest,
         game_id: &String,
         version_id: &String,
     ) -> anyhow::Result<()> {
-        todo!()
+        self.put_object(
+            PathBuf::from(game_id)
+                .join(version_id)
+                .join("manifest.json")
+                .to_string_lossy()
+                .to_string(),
+            json!(manifest).to_string().as_bytes(),
+        )
+        .await?;
+        Ok(())
+    }
+}
+
+impl Deref for S3 {
+    type Target = Bucket;
+
+    fn deref(&self) -> &Self::Target {
+        &self.bucket
     }
 }

cli/src/commands/upload/speedtest.rs

@@ -0,0 +1,33 @@
+use rand::{RngCore, SeedableRng, rng, rngs::StdRng};
+use tokio::io::AsyncRead;
+
+#[derive(Clone, Debug)]
+pub struct Speedtest {
+    core: rand::rngs::StdRng,
+    to_write: usize,
+}
+pub const SPEEDTEST_BYTES: usize = 64 * 1024 * 1024;
+pub const SPEEDTEST_PATH: &str = "speedtest";
+
+impl AsyncRead for Speedtest {
+    fn poll_read(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> std::task::Poll<std::io::Result<()>> {
+        let mut s = self;
+        let to_write = buf.remaining().min(s.to_write);
+        s.to_write = s.to_write.saturating_sub(to_write);
+        let fill_slice = buf.initialize_unfilled_to(to_write);
+        s.core.fill_bytes(fill_slice);
+        std::task::Poll::Ready(Ok(()))
+    }
+}
+impl Speedtest {
+    pub fn new() -> Self {
+        Self {
+            core: StdRng::from_rng(&mut rng()),
+            to_write: SPEEDTEST_BYTES,
+        }
+    }
+}

cli/src/commands/upload/uploadable.rs

@@ -1,20 +1,15 @@
+use async_trait::async_trait;
 use droplet_rs::manifest::{ChunkData, Manifest};
 
+#[async_trait]
 pub trait Uploadable {
-    fn upload_chunk(
+    async fn upload_chunk(
         &mut self,
         id: &String,
         version: &String,
         chunk_id: &String,
         chunk: &ChunkData,
     ) -> anyhow::Result<()>;
-    fn upload_speedtest(&mut self, game_id: &String, version_id: &String) -> anyhow::Result<()>;
-    fn upload_manifest(&mut self, manifest: Manifest, game_id: &String, version_id: &String) -> anyhow::Result<()>;
-}
-pub enum UploadableConfig {
-    S3 {
-        api_secret: String,
-        api_key_identifier: String,
-        region: String,
-    },
+    async fn upload_speedtest(&mut self) -> anyhow::Result<()>;
+    async fn upload_manifest(&mut self, manifest: Manifest, game_id: &String, version_id: &String) -> anyhow::Result<()>;
 }

cli/src/commands/upload/void.rs

@@ -1,11 +1,13 @@
+use async_trait::async_trait;
 use droplet_rs::manifest::{ChunkData, Manifest};
 use log::warn;
 
 use crate::commands::upload::uploadable::Uploadable;
 
 pub struct VoidUploadable;
+#[async_trait]
 impl Uploadable for VoidUploadable {
-    fn upload_chunk(
+    async fn upload_chunk(
         &mut self,
         _id: &String,
         _version: &String,
@@ -16,12 +18,12 @@ impl Uploadable for VoidUploadable {
         Ok(())
     }
 
-    fn upload_speedtest(&mut self, _game_id: &String, _version_id: &String) -> anyhow::Result<()> {
+    async fn upload_speedtest(&mut self) -> anyhow::Result<()> {
         warn!("Uploading speedtest to VoidUploader");
         Ok(())
     }
 
-    fn upload_manifest(
+    async fn upload_manifest(
         &mut self,
         _manifest: Manifest,
         _game_id: &String,