style: minor function naming changes

Author: Taxrosdev

src/commands/main.rs

@@ -9,7 +9,7 @@ use flintpkg::{
     build::build,
     chunks::{utils::clean_unused, verify_all_chunks},
     repo::{PackageManifest, get_package, read_manifest},
-    run::{install, start},
+    run::{install_package, start},
     utils::{resolve_package, resolve_repo},
 };
 
@@ -48,7 +48,7 @@ pub async fn install_cmd(
         }
     };
 
-    install(&target_repo_path, package_id, chunk_store_path).await?;
+    install_package(&target_repo_path, package_id, chunk_store_path).await?;
 
     Ok(())
 }
@@ -139,7 +139,7 @@ pub async fn run_cmd(
         .join("install.meta")
         .exists()
     {
-        install(&target_repo_path, &package, chunk_store_path)
+        install_package(&target_repo_path, &package, chunk_store_path)
             .await
             .with_context(|| "Failed to install package.")?;
     }

src/main.rs

@@ -203,7 +203,7 @@ async fn update_all_repos(base_path: &Path, chunk_store_path: &Path) -> Result<(
         get_all_installed_packages, get_package, network::update_repository, read_manifest,
         remove_package,
     };
-    use flintpkg::run::install;
+    use flintpkg::run::install_package;
 
     for entry in base_path.read_dir()? {
         let repo = entry?;
@@ -225,7 +225,7 @@ async fn update_all_repos(base_path: &Path, chunk_store_path: &Path) -> Result<(
                 if installed_package != repo_package {
                     updated_package(&repo_package);
 
-                    install(&repo_path, &repo_package.id, chunk_store_path).await?;
+                    install_package(&repo_path, &repo_package.id, chunk_store_path).await?;
                 }
             } else {
                 remove_package(&installed_package.id, &repo_path, None)?;

src/repo/mod.rs

@@ -2,6 +2,7 @@ mod manifest;
 mod manifest_io;
 #[cfg(feature = "network")]
 pub mod network;
+pub mod versions;
 pub use manifest::*;
 pub use manifest_io::{read_manifest, update_manifest};
 

src/repo/versions.rs

@@ -0,0 +1,78 @@
+use anyhow::{Context, Result};
+use std::{fs, os::unix::fs::symlink, path::Path};
+
+use crate::{
+    chunks::{HashKind, hash::hash, load_tree},
+    repo::{PackageManifest, get_package, read_manifest},
+};
+
+fn hash_package(package_manifest: &PackageManifest, hash_kind: HashKind) -> Result<String> {
+    let hash_str = serde_yaml::to_string(package_manifest)?;
+
+    Ok(hash(hash_kind, hash_str.as_bytes()))
+}
+
+/// Installs the latest version of a package, assumes all chunks are available.
+/// It is recommended you call `autoclean_versions` after.
+///
+/// # Errors
+///
+/// - Filesystem errors (Out of space, Permissions)
+/// - Invalid Repository/Package manifest
+pub fn install_version(repo_path: &Path, package_id: &str, chunk_store_path: &Path) -> Result<()> {
+    let repo_manifest = read_manifest(repo_path)?;
+
+    let package_manifest = get_package(&repo_manifest, package_id)
+        .with_context(|| "Failed to get package from Repository.")?;
+    let package_hash = hash_package(&package_manifest, repo_manifest.hash_kind)?;
+    let installed_path = &repo_path
+        .join("versions")
+        .join(format!("{}-{}", package_manifest.id, package_hash));
+
+    load_tree(installed_path, chunk_store_path, &package_manifest.chunks)
+        .with_context(|| "Failed to rebuild the tree.")?;
+
+    fs::write(
+        installed_path.join("install.meta"),
+        serde_yaml::to_string(&package_manifest)?,
+    )?;
+
+    Ok(())
+}
+
+pub fn switch_version(repo_path: &Path, hash: String, package_id: &str) -> Result<()> {
+    let target_parent_path = repo_path.join("installed");
+    let target_path = target_parent_path.join(package_id);
+    symlink(format!("../versions/{package_id}-{hash}"), target_path)?;
+
+    Ok(())
+}
+
+/// Gets all versions for the `package_id`
+pub fn get_versions(repo_path: &Path, package_id: &str) -> Result<Vec<String>> {
+    let mut versions = Vec::new();
+
+    for entry in repo_path.join("versions").read_dir()? {
+        if let Ok(entry) = entry
+            && let Ok(file_name) = entry.file_name().into_string()
+        {
+            let split: Vec<&str> = file_name.split('-').collect();
+
+            if let Some((version_hash, file_name_split)) = split.split_last()
+                && file_name_split.join("-") == package_id
+            {
+                versions.push((*version_hash).to_string());
+            }
+        }
+    }
+
+    Ok(versions)
+}
+
+/// Removes a version of a package.
+pub fn remove_version(repo_path: &Path, hash: String, package_id: &str) -> Result<()> {
+    let path = repo_path.join(format!("versions/{}-{}", package_id, hash));
+    fs::remove_dir_all(path)?;
+
+    Ok(())
+}

src/run/mod.rs

@@ -4,17 +4,13 @@ use anyhow::{Context, Result, bail};
 use std::{
     collections::HashMap,
     ffi::OsStr,
-    fs,
     path::{Path, PathBuf},
     process::{Command, ExitStatus},
 };
 
 #[cfg(feature = "network")]
 use crate::chunks::install_tree;
-use crate::{
-    chunks::load_tree,
-    repo::{self, PackageManifest, read_manifest},
-};
+use crate::repo::{PackageManifest, get_package, read_manifest, versions::install_version};
 
 /// Starts a package from an entrypoint
 ///
@@ -72,18 +68,23 @@ pub fn start<S: AsRef<OsStr>>(
     }
 }
 
-/// Installs or Updates a Package.
+/// Installs the latest version of a package, assumes all chunks are available.
+/// Will automatically autoclean.
 ///
 /// # Errors
 ///
 /// - Filesystem errors (Out of space, Permissions)
 /// - Invalid Repository/Package manifest
-pub async fn install(repo_path: &Path, package_id: &str, chunk_store_path: &Path) -> Result<()> {
+/// - Network Errors (If network is enabled)
+pub async fn install_package(
+    repo_path: &Path,
+    package_id: &str,
+    chunk_store_path: &Path,
+) -> Result<()> {
     let repo_manifest = read_manifest(repo_path)?;
 
-    let package_manifest = repo::get_package(&repo_manifest, package_id)
+    let package_manifest = get_package(&repo_manifest, package_id)
         .with_context(|| "Failed to get package from Repository.")?;
-    let installed_path = &repo_path.join("installed").join(&package_manifest.id);
 
     // Get any chunks that are not installed
     #[cfg(feature = "network")]
@@ -96,15 +97,7 @@ pub async fn install(repo_path: &Path, package_id: &str, chunk_store_path: &Path
     .await
     .with_context(|| "Failed to install package.")?;
 
-    load_tree(installed_path, chunk_store_path, &package_manifest.chunks)
-        .with_context(|| "Failed to rebuild the tree.")?;
-
-    fs::write(
-        installed_path.join("install.meta"),
-        serde_yaml::to_string(&package_manifest)?,
-    )?;
-
-    Ok(())
+    install_version(repo_path, package_id, chunk_store_path)
 }
 
 #[cfg(test)]
@@ -154,7 +147,7 @@ mod tests {
         insert_package(&package, repo_path, Some(repo_path))?;
 
         // Now install
-        install(repo_path, "testpkg", chunks_path).await?;
+        install_package(repo_path, "testpkg", chunks_path).await?;
 
         // Check installed
         let installed_path = repo_path.join("installed/testpkg");

tests/full_workflow.rs

@@ -5,7 +5,7 @@ use temp_dir::TempDir;
 use flintpkg::{
     build::build,
     repo::{self, get_installed_package},
-    run::{install, start},
+    run::{install_package, start},
 };
 
 #[tokio::test]
@@ -20,7 +20,7 @@ async fn full_workflow_test() -> Result<()> {
     let build_manifest_path = Path::new("build_manifest.yml");
     build(build_manifest_path, repo_path, None, chunks_path).await?;
 
-    install(repo_path, "example", chunks_path).await?;
+    install_package(repo_path, "example", chunks_path).await?;
 
     let manifest = get_installed_package(repo_path, "example")?;