downloading works

Cargo.toml

@@ -62,3 +62,4 @@ cliclack = "0.2.5"
 os_info = { version = "3.7", default-features = false }
 lazy_static = "1.4"
 bytes = "1.6"
+murmur2 = "0.1.0"

TECHNICAL.md

@@ -0,0 +1,12 @@
+# Technical Documentation
+
+meow
+
+Everything starts at the [`App`](./src/api/app/mod.rs) struct.
+
+- `App::collect_sources(&self) -> Vec<Source>`
+- `Source::resolve_addons(&App) -> Vec<Addon>`
+- `App::collect_addons(&self) -> Vec<Addon>`
+- `Addon::resolve_steps(&App) -> Vec<Step>`
+- `App::execute_steps(&self, &[Step]) -> Result<()>`
+- `App::execute_step(&self, Step) -> Result<StepResult>`

src/api/app/actions/build/mod.rs

@@ -1,5 +1,30 @@
-use crate::api::app::App;
+use std::path::Path;
+
+use anyhow::Result;
+
+use crate::api::{app::App, models::Addon};
 
 impl App {
-
+    pub async fn action_install_jar(&self) -> Result<()> {
+
+
+        Ok(())
+    }
+
+    pub async fn action_install_addon(&self, base: &Path, addon: &Addon) -> Result<()> {
+        let steps = addon.resolve_steps(&self).await?;
+        let dir = base.join(addon.target.as_str());
+        self.execute_steps(&dir, &steps).await?;
+        Ok(())
+    }
+
+    pub async fn action_install_addons(&self, base: &Path) -> Result<()> {
+        let addons = self.collect_addons().await?;
+
+        for addon in &addons {
+            self.action_install_addon(base, addon).await?;
+        }
+
+        Ok(())
+    }
 }

src/api/app/cache/mod.rs

@@ -7,13 +7,20 @@ use std::{
 use anyhow::{Context, Result};
 use serde::de::DeserializeOwned;
 
+use crate::api::step::CacheLocation;
+
 pub struct Cache(pub Option<PathBuf>);
 
 impl Cache {
     pub fn new(path: Option<PathBuf>) -> Self {
         Self(path)
     }
 
+    pub fn loc(&self, loc: Option<&CacheLocation>) -> Option<PathBuf> {
+        let loc = loc?;
+        self.join(&format!("{}/{}", loc.0, loc.1))
+    }
+
     pub fn join(&self, path: &str) -> Option<PathBuf> {
         Some(self.0.as_ref()?.join(path))
     }

src/api/app/mod.rs

@@ -13,6 +13,7 @@ use super::{models::{network::{Network, NETWORK_TOML}, server::{Server, SERVER_T
 pub mod actions;
 pub mod cache;
 pub mod options;
+pub mod step;
 
 pub const APP_USER_AGENT: &str = concat!(
     env!("CARGO_PKG_NAME"),
@@ -39,7 +40,7 @@ impl App {
             .build()
             .context("Initializing http_client")?;
 
-        let cache = Cache::new(dirs::cache_dir());
+        let cache = Cache::new(dirs::cache_dir().map(|p| p.join("mcman")));
 
         let (server_path, server) = try_find_toml_upwards::<Server>(SERVER_TOML)?.unzip();
         let (network_path, network) = try_find_toml_upwards::<Network>(NETWORK_TOML)?.unzip();

src/api/app/step.rs

@@ -0,0 +1,88 @@
+use std::path::Path;
+
+use anyhow::{anyhow, bail, Result};
+use tokio_stream::StreamExt;
+
+use crate::api::{models::Addon, step::{CacheLocation, Step, StepResult}, utils::hashing::get_best_hash};
+
+use super::App;
+
+impl App {
+    pub async fn execute_steps(&self, dir: &Path, steps: &[Step]) -> Result<()> {
+        for step in steps {
+            let res = self.execute_step(dir, step).await?;
+
+            if res == StepResult::Skip {
+                break;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub async fn execute_step(&self, dir: &Path, step: &Step) -> Result<StepResult> {
+        match step {
+            Step::CacheCheck(metadata) => {
+                if let Some(cache) = &metadata.cache {
+
+                }
+
+                Ok(StepResult::Continue)
+            },
+
+            Step::Download { url, metadata } => {
+                let cache_destination = self.cache.loc(metadata.cache.as_ref());
+                let output_destination = dir.join(&metadata.filename);
+
+                let res = self.http_get(url).await?;
+
+                let content_length = res.content_length();
+                match (metadata.size, content_length) {
+                    (Some(a), Some(b)) if a != b => {
+                        bail!("Mismatched Content-Length! Expected {a}, recieved {b}");
+                    },
+                    _ => {},
+                }
+
+                let mut stream = res.bytes_stream();
+
+                let mut hasher = get_best_hash(&metadata.hashes).map(|(format, content)| {
+                    (format, format.get_digest(), content)
+                });
+
+                let target_destination = cache_destination.as_ref().unwrap_or(&output_destination);
+                tokio::fs::create_dir_all(target_destination.parent().ok_or(anyhow!("No parent"))?).await?;
+
+                let target_file = tokio::fs::File::create(&target_destination).await?;
+                let mut target_writer = tokio::io::BufWriter::new(target_file);
+
+                while let Some(item) = stream.try_next().await? {
+                    if let Some((_, ref mut digest, _ )) = hasher {
+                        digest.update(&item);
+                    }
+
+                    tokio::io::copy(&mut item.as_ref(), &mut target_writer).await?;
+                }
+
+                if let Some((_, hasher, content)) = hasher {
+                    let hash = hex::encode(&hasher.finalize());
+
+                    if hash != content {
+                        bail!("Mismatched hash!");
+                    }
+                }
+
+                if let Some(cache_destination) = cache_destination {
+                    tokio::fs::create_dir_all(output_destination.parent().ok_or(anyhow!("No parent"))?).await?;
+                    tokio::fs::copy(&cache_destination, &output_destination).await?;
+                }
+
+                println!("Downloaded {}", metadata.filename);
+
+                Ok(StepResult::Continue)
+            },
+
+            Step::Execute => Ok(StepResult::Continue),
+        }
+    }
+}

src/api/models/addon/addon_target.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
@@ -35,4 +35,8 @@ impl AddonTarget {
     pub fn from_path(path: &str) -> Self {
         Self::from_str(&Path::new(path).parent().map(|p| p.to_string_lossy().into_owned()).unwrap_or(".".to_owned()))
     }
+
+    pub fn to_path(&self) -> PathBuf {
+        PathBuf::from(self.as_str())
+    }
 }

src/api/sources/curseforge/mod.rs

@@ -0,0 +1 @@
+mod models;

src/api/sources/mod.rs

@@ -1,11 +1,10 @@
-use std::collections::HashMap;
-
 use anyhow::Result;
 
-use super::{app::App, step::{CacheStrategy, Step}, utils::url::get_filename_from_url};
+use super::{app::App, step::{FileMeta, Step}, utils::url::get_filename_from_url};
 
 pub mod vanilla;
 pub mod modrinth;
+pub mod curseforge;
 
 pub async fn resolve_steps_for_url(
     app: &App,
@@ -18,17 +17,16 @@ pub async fn resolve_steps_for_url(
         get_filename_from_url(&url)
     });
 
+    let metadata = FileMeta {
+        cache: None,
+        filename,
+        ..Default::default()
+    };
+
     Ok(vec![
-        Step::CacheCheck(CacheStrategy::Indexed {
-            namespace: "url".into(),
-            path: None,
-            key: url.clone(),
-        }),
         Step::Download {
             url: url.into(),
-            filename,
-            size: None,
-            hashes: HashMap::new(),
+            metadata,
         }
     ])
 }

src/api/sources/modrinth/mod.rs

@@ -2,10 +2,9 @@ use anyhow::{anyhow, Result};
 use models::{ModrinthFile, ModrinthProject, ModrinthVersion};
 use serde::de::DeserializeOwned;
 
-use crate::api::{app::App, step::{CacheStrategy, Step}};
+use crate::api::{app::App, step::{CacheLocation, FileMeta, Step}};
 
 mod models;
-mod ratelimit;
 
 pub struct ModrinthAPI<'a>(pub &'a App);
 
@@ -94,16 +93,18 @@ impl<'a> ModrinthAPI<'a> {
     pub async fn resolve_steps(&self, id: &str, version: &str) -> Result<Vec<Step>> {
         let (file, version) = self.fetch_file(id, version).await?;
 
+        let metadata = FileMeta {
+            cache: Some(CacheLocation("modrinth".into(), format!("{id}/{}/{}", version.id, file.filename))),
+            filename: file.filename,
+            size: Some(file.size),
+            hashes: file.hashes,
+        };
+
         Ok(vec![
-            Step::CacheCheck(CacheStrategy::File {
-                namespace: "modrinth".into(),
-                path: format!("{id}/{}/{}", version.id, file.filename),
-            }),
+            Step::CacheCheck(metadata.clone()),
             Step::Download {
                 url: file.url,
-                filename: file.filename,
-                size: Some(file.size),
-                hashes: file.hashes,
+                metadata,
             },
         ])
     }

src/api/sources/vanilla/mod.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use anyhow::{anyhow, bail, Result};
 
-use crate::api::{app::App, models::Environment, step::Step};
+use crate::api::{app::App, models::Environment, step::{CacheLocation, FileMeta, Step}, utils::hashing::HashFormat};
 
 mod assets;
 mod manifest;
@@ -9,6 +11,31 @@ mod rulematcher;
 
 pub use self::{assets::*, manifest::*, version::*, rulematcher::*};
 
+impl VersionInfo {
+    pub fn into_step(&self, ty: DownloadType) -> Option<Vec<Step>> {
+        let file = self.downloads.get(&ty)?;
+
+        let filename = format!("{}-{ty:?}.jar", self.id);
+
+        let metadata = FileMeta {
+            filename: filename.clone(),
+            cache: Some(CacheLocation("pistonmeta".into(), filename)),
+            size: Some(file.size),
+            hashes: HashMap::from([
+                (HashFormat::Sha1, file.sha1.clone())
+            ]),
+        };
+
+        Some(vec![
+            Step::CacheCheck(metadata.clone()),
+            Step::Download {
+                url: file.url.clone(),
+                metadata,
+            },
+        ])
+    }
+}
+
 pub struct VanillaAPI<'a>(pub &'a App);
 
 impl<'a> VanillaAPI<'a> {

src/api/sources/vanilla/version.rs

@@ -2,8 +2,6 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
-use crate::api::{step::{CacheStrategy, Step}, utils::hashing::HashFormat};
-
 use super::VersionType;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
@@ -33,26 +31,6 @@ pub struct VersionInfo {
     pub release_time: String,
 }
 
-impl VersionInfo {
-    pub fn into_step(&self, ty: DownloadType) -> Option<Vec<Step>> {
-        let file = self.downloads.get(&ty)?;
-
-        let filename = format!("{}-{ty:?}.jar", self.id);
-
-        Some(vec![
-            Step::CacheCheck(CacheStrategy::File { namespace: "pistonmeta".into(), path: filename.clone() }),
-            Step::Download {
-                url: file.url.clone(),
-                filename: filename,
-                size: Some(file.size),
-                hashes: HashMap::from([
-                    (HashFormat::Sha1, file.sha1.clone())
-                ]),
-            },
-        ])
-    }
-}
-
 #[derive(Debug, Clone, Copy, Deserialize, Serialize, Hash, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 pub enum DownloadType {