rattler 0.43.2

Rust library to install conda environments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use simple_spawn_blocking::Cancelled;
use std::{collections::HashMap, path::PathBuf};

use crate::{
    install::{
        InstallError, TransactionError,
        clobber_registry::{ClobberError, ClobberedPath},
        driver::PostProcessingError,
        link_script::PrePostLinkError,
        unlink::UnlinkError,
    },
    package_cache::PackageCacheError,
};

/// An error returned by the installer
#[derive(Debug, thiserror::Error)]
pub enum InstallerError {
    /// Failed to determine the currently installed packages.
    #[error("failed to determine the currently installed packages")]
    FailedToDetectInstalledPackages(#[source] std::io::Error),

    /// Failed to construct a transaction
    #[error("failed to construct a transaction")]
    FailedToConstructTransaction(#[from] TransactionError),

    /// Failed to populate the cache with the package
    #[error("failed to fetch {0}")]
    FailedToFetch(String, #[source] PackageCacheError),

    /// Failed to link a certain package
    #[error("failed to link {0}")]
    LinkError(String, #[source] InstallError),

    /// Failed to unlink a certain package
    #[error("failed to unlink {0}")]
    UnlinkError(String, #[source] UnlinkError),

    /// A generic IO error occurred
    #[error("{0}")]
    IoError(String, #[source] std::io::Error),

    /// Failed to run a pre-link script
    #[error("pre-processing failed")]
    PreProcessingFailed(#[source] PrePostLinkError),

    /// Failed to run a post-link script
    #[error("post-processing failed")]
    PostProcessingFailed(#[source] PrePostLinkError),

    /// A clobbering error occurred
    #[error("failed to unclobber clobbered files")]
    ClobberError(#[from] ClobberError),

    /// Clobbering was detected and the clobber mode is set to error.
    #[error("{} file(s) are provided by multiple packages", .0.len())]
    ClobberingDetected(HashMap<PathBuf, ClobberedPath>),

    /// The operation was cancelled
    #[error("the operation was cancelled")]
    Cancelled,

    /// Failed to create the prefix
    #[error("failed to create the prefix")]
    FailedToCreatePrefix(PathBuf, #[source] std::io::Error),

    /// Attempted to install platform-specific packages when target platform is noarch
    #[error("cannot install platform-specific packages with noarch as the target platform. The following packages have non-noarch subdirs: {}", .0.join(", "))]
    PlatformSpecificPackagesWithNoarchPlatform(Vec<String>),

    /// Failed to acquire the global cache lock
    #[error("failed to acquire global cache lock")]
    FailedToAcquireCacheLock(#[source] PackageCacheError),
}

impl From<Cancelled> for InstallerError {
    fn from(_: Cancelled) -> Self {
        InstallerError::Cancelled
    }
}

impl From<PostProcessingError> for InstallerError {
    fn from(value: PostProcessingError) -> Self {
        match value {
            PostProcessingError::ClobberError(err) => InstallerError::ClobberError(err),
            PostProcessingError::FailedToDetectInstalledPackages(err) => {
                InstallerError::FailedToDetectInstalledPackages(err)
            }
            PostProcessingError::ClobberingDetected(paths) => {
                InstallerError::ClobberingDetected(paths)
            }
        }
    }
}