Refactor

Author: SamuelSarle

lib/asimov-installer/src/installer.rs

@@ -2,12 +2,11 @@
 
 use asimov_module::{InstalledModuleManifest, ModuleManifest, tracing};
 use std::{path::Path, string::String};
-use tokio::io;
 
 pub mod error;
 use error::*;
 
-use asimov_registry::{Registry, error::ReadManifestError};
+use asimov_registry::Registry;
 
 mod github;
 mod platform;
@@ -50,13 +49,8 @@ impl Installer {
             .preinstall(module_name.as_ref(), version.as_ref(), temp_dir.path())
             .await?;
 
-        self.finish_install(
-            module_name.as_ref(),
-            version.as_ref(),
-            manifest,
-            temp_dir.path(),
-        )
-        .await?;
+        self.finish_install(version.as_ref(), manifest, temp_dir.path())
+            .await?;
 
         Ok(())
     }
@@ -98,7 +92,7 @@ impl Installer {
         // now ok to uninstall old version
         self.uninstall_module(module_name).await?;
 
-        self.finish_install(module_name, version, manifest, temp_dir.path())
+        self.finish_install(version, manifest, temp_dir.path())
             .await?;
 
         if was_enabled {
@@ -112,37 +106,19 @@ impl Installer {
         &self,
         module_name: impl AsRef<str>,
     ) -> Result<(), UninstallError> {
-        let manifest_path = self
-            .registry
-            .find_manifest_file(module_name.as_ref())
-            .await?
-            .ok_or(UninstallError::NotInstalled)?;
-
-        let manifest = read_manifest(&manifest_path).await?;
+        let manifest = self.registry.read_manifest(&module_name).await?;
 
         self.registry.disable_module(&module_name).await?;
 
-        tokio::fs::remove_file(&manifest_path).await.or_else(|e| {
-            if e.kind() == io::ErrorKind::NotFound {
-                Ok(())
-            } else {
-                Err(UninstallError::Delete(manifest_path, e))
-            }
-        })?;
-
-        let exec_dir = self.registry.exec_dir();
-
-        for program in manifest.manifest.provides.programs {
-            let path = exec_dir.join(program);
-            tokio::fs::remove_file(&path).await.or_else(|e| {
-                if e.kind() == io::ErrorKind::NotFound {
-                    Ok(())
-                } else {
-                    Err(UninstallError::Delete(path, e))
-                }
-            })?;
+        for program in &manifest.manifest.provides.programs {
+            self.registry
+                .remove_binary(program)
+                .await
+                .map_err(|e| UninstallError::RemoveBinary(program.into(), e))?;
         }
 
+        self.registry.remove_manifest(&module_name).await?;
+
         Ok(())
     }
 
@@ -156,9 +132,7 @@ impl Installer {
 
         let release = github::fetch_release(&self.client, module_name, version)
             .await
-            .map_err(|_| {
-                PreinstallError::CreateManifestDir(std::io::Error::other("Failed to fetch release"))
-            })?;
+            .map_err(PreinstallError::FetchRelease)?;
 
         let Some(asset) = github::find_matching_asset(&release.assets, module_name, &platform)
         else {
@@ -193,58 +167,24 @@ impl Installer {
 
     async fn finish_install(
         &self,
-        module_name: &str,
         version: &str,
         manifest: ModuleManifest,
         temp_dir: &Path,
     ) -> Result<(), FinishInstallError> {
         let extract_dir = temp_dir.join("extract");
 
-        let manifest_path = self
-            .registry
-            .install_dir()
-            .join(std::format!("{module_name}.json"));
-
-        github::install_binaries(&manifest, &extract_dir, &self.registry.exec_dir())
-            .await
-            .map_err(FinishInstallError::BinaryInstall)?;
+        for program in &manifest.provides.programs {
+            let src = extract_dir.join(program);
+            self.registry.add_binary(program, &src).await?;
+        }
 
         let installed_manifest = InstalledModuleManifest {
             version: Some(version.into()),
             manifest,
         };
-        let mut manifest_json = serde_json::to_string_pretty(&installed_manifest)?;
-        manifest_json.push('\n'); // always newline-terminate text files
 
-        tokio::fs::write(&manifest_path, &manifest_json)
-            .await
-            .map_err(FinishInstallError::SaveManifest)?;
+        self.registry.add_manifest(installed_manifest).await?;
 
         Ok(())
     }
 }
-
-async fn read_manifest(
-    path: impl AsRef<Path>,
-) -> Result<InstalledModuleManifest, ReadManifestError> {
-    let manifest = match path.as_ref().extension().and_then(|ext| ext.to_str()) {
-        Some("yaml") | Some("yml") => {
-            let content = tokio::fs::read(&path)
-                .await
-                .map_err(ReadManifestError::InstalledManifestIo)?;
-
-            serde_yaml_ng::from_slice::<'_, InstalledModuleManifest>(&content)?
-        },
-        Some("json") => {
-            let content = tokio::fs::read(&path)
-                .await
-                .map_err(ReadManifestError::InstalledManifestIo)?;
-
-            serde_json::from_slice::<'_, InstalledModuleManifest>(&content)?
-        },
-        ext => Err(ReadManifestError::UnknownManifestFormat(
-            ext.map(Into::into),
-        ))?,
-    };
-    Ok(manifest)
-}

lib/asimov-installer/src/installer/error.rs

@@ -4,7 +4,6 @@ use super::platform::PlatformInfo;
 use asimov_registry::error as registry;
 use std::{
     io,
-    path::PathBuf,
     string::{String, ToString as _},
 };
 use thiserror::Error;
@@ -39,16 +38,14 @@ pub enum UpgradeError {
 
 #[derive(Debug, Error)]
 pub enum UninstallError {
-    #[error("error while searching for manifest file: {0}")]
-    FindManifest(#[from] registry::FindManifestError),
     #[error("unable to read module manifest file: {0}")]
-    Read(#[from] registry::ReadManifestError),
+    Read(#[from] registry::ManifestError),
     #[error(transparent)]
     Disable(#[from] registry::DisableError),
-    #[error("unable to remove installed module file `{0}`: {1}")]
-    Delete(PathBuf, io::Error),
-    #[error("module is not installed")]
-    NotInstalled,
+    #[error("unable to remove installed module binary `{0}`: {1}")]
+    RemoveBinary(String, #[source] registry::RemoveBinaryError),
+    #[error("unable to remove installed module manifest: {0}")]
+    RemoveManifest(#[from] registry::RemoveManifestError),
 }
 
 mod common {
@@ -120,12 +117,8 @@ mod common {
 
     #[derive(Debug, Error)]
     pub enum PreinstallError {
-        #[error("failed to create directory for installed manifests: {0}")]
-        CreateManifestDir(io::Error),
-        #[error("failed to create directory for installed binaries: {0}")]
-        CreateExecDir(io::Error),
-        #[error("failed to create directory for extracting: {0}")]
-        CreateExtractDir(io::Error),
+        #[error("failed fetch release: {0}")]
+        FetchRelease(FetchError),
 
         #[error("no binaries available for platform `{}-{}{}`", .0.os, .0.arch, if let Some(ref libc) = .0.libc { "-".to_string() + libc } else { "".to_string() })]
         NotAvailable(PlatformInfo),
@@ -140,18 +133,19 @@ mod common {
         #[error(transparent)]
         VerifyChecksum(#[from] VerifyChecksumError),
 
+        #[error("failed to create directory for extracting: {0}")]
+        CreateExtractDir(io::Error),
+
         #[error("failed to extract archive: {0}")]
         Extract(io::Error),
     }
 
     #[derive(Debug, Error)]
     pub enum FinishInstallError {
-        #[error("failed to install binaries: {0}")]
-        BinaryInstall(io::Error),
-        #[error("failed to serialize module manifest: {0}")]
-        SerializeManifest(#[from] serde_json::Error),
-        #[error("failed to save module manifest: {0}")]
-        SaveManifest(io::Error),
+        #[error("failed to install binary: {0}")]
+        AddBinary(#[from] registry::AddBinaryError),
+        #[error("failed to add manifest: {0}")]
+        AddManifest(#[from] registry::AddManifestError),
     }
 }
 pub use common::*;

lib/asimov-installer/src/installer/github.rs

@@ -247,25 +247,3 @@ pub async fn extract_files(
 
     Ok(())
 }
-
-pub async fn install_binaries(
-    manifest: &ModuleManifest,
-    extract_dir: &Path,
-    install_dir: &Path,
-) -> Result<(), tokio::io::Error> {
-    for program in &manifest.provides.programs {
-        let src = extract_dir.join(program);
-        let dst = install_dir.join(program);
-
-        tokio::fs::copy(&src, &dst).await?;
-
-        #[cfg(unix)]
-        {
-            use std::fs::Permissions;
-            use std::os::unix::fs::PermissionsExt;
-            tokio::fs::set_permissions(&dst, Permissions::from_mode(0o755)).await?;
-        }
-    }
-
-    Ok(())
-}