holochain 0.6.0

Holochain, a framework for distributed applications
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Error types for the conductor.

use super::entry_def_store::error::EntryDefStoreError;
use super::interface::error::InterfaceError;
use crate::conductor::cell::error::CellError;
use crate::core::workflow::WorkflowError;
use holochain_conductor_api::conductor::ConductorConfigError;
use holochain_sqlite::error::DatabaseError;
use holochain_types::prelude::*;
use holochain_wasmer_host::prelude::WasmErrorInner;
use holochain_zome_types::cell::CellId;
use thiserror::Error;

/// Custom result type for conductor errors with [`ConductorError`] as the error type.
pub type ConductorResult<T> = Result<T, ConductorError>;

#[allow(missing_docs)]
#[derive(Error, Debug)]
pub enum ConductorError {
    #[error("Internal Cell error: {0}")]
    InternalCellError(#[from] CellError),

    #[error(transparent)]
    AppError(#[from] AppError),

    #[error(transparent)]
    AppBundleError(#[from] AppBundleError),

    #[error("App can't be disabled/uninstalled because it is protected by its dependents. App: {0} Dependents: {1:?}")]
    AppHasDependents(InstalledAppId, Vec<InstalledAppId>),

    #[error(transparent)]
    AppManifestError(#[from] AppManifestError),

    #[error(transparent)]
    DatabaseError(#[from] DatabaseError),

    #[error("Cell already exists. CellId: {0:?}")]
    CellAlreadyExists(CellId),

    #[error("Cell was referenced, but is currently disabled. CellId: {0:?}")]
    CellDisabled(CellId),

    #[error("Cell was referenced, but is missing from the conductor. CellId: {0:?}")]
    CellMissing(CellId),

    #[error("Error while cloning cell: {0}")]
    CloneCellError(String),

    #[error(transparent)]
    ConductorConfigError(#[from] ConductorConfigError),

    #[error(transparent)]
    CountersigningError(#[from] CountersigningError),

    #[error("Config deserialization error: {0}")]
    SerializationError(#[from] serde_yaml::Error),

    #[error("Attempted to call into the conductor while it is shutting down")]
    ShuttingDown,

    #[error("Error while performing IO for the Conductor: {0}")]
    IoError(#[from] std::io::Error),

    #[error("Error while trying to send a task to the task manager: {0}")]
    SubmitTaskError(String),

    #[error("ZomeError: {0}")]
    ZomeError(#[from] holochain_zome_types::zome::ZomeError),

    #[error("DnaError: {0}")]
    DnaError(#[from] holochain_types::dna::DnaError),

    #[error("Workflow error: {0:?}")]
    WorkflowError(#[from] WorkflowError),

    // Box is to avoid cycle in error definition
    #[error(transparent)]
    InterfaceError(#[from] Box<InterfaceError>),

    #[error("Failed to run genesis on the following cells in the app: {errors:?}")]
    GenesisFailed { errors: Vec<(CellId, CellError)> },

    #[error(transparent)]
    SerializedBytesError(#[from] holochain_serialized_bytes::SerializedBytesError),

    #[error("Wasm code was not found in the wasm store")]
    WasmMissing,

    #[error("Tried to access an app that was not installed: {0}")]
    AppNotInstalled(InstalledAppId),

    #[error("Tried to install an app using an already-used InstalledAppId: {0}")]
    AppAlreadyInstalled(InstalledAppId),

    #[error("App status could not be changed: {0}")]
    AppStatusError(String),

    #[error(transparent)]
    HolochainP2pError(#[from] holochain_p2p::HolochainP2pError),

    #[error(transparent)]
    EntryDefStoreError(#[from] EntryDefStoreError),

    #[error(transparent)]
    KeystoreError(#[from] holochain_keystore::KeystoreError),

    #[error(transparent)]
    MrBundleError(#[from] mr_bundle::error::MrBundleError),

    #[error(transparent)]
    SourceChainError(#[from] holochain_state::source_chain::SourceChainError),

    #[error(transparent)]
    StateQueryError(#[from] holochain_state::query::StateQueryError),

    #[error(transparent)]
    StateMutationError(#[from] holochain_state::mutations::StateMutationError),

    #[error(transparent)]
    JoinError(#[from] tokio::task::JoinError),

    #[error(transparent)]
    RusqliteError(#[from] rusqlite::Error),

    #[error(transparent)]
    RibosomeError(#[from] crate::core::ribosome::error::RibosomeError),

    #[error("Authentication failed with reason: {0}")]
    FailedAuthenticationError(String),

    #[error("App {0} is not allowed to access: {1:?}")]
    AppAccessError(InstalledAppId, Box<dyn std::fmt::Debug + Send + Sync>),

    /// Other
    #[error("Other: {0}")]
    Other(Box<dyn std::error::Error + Send + Sync>),

    #[error("The conductor has no data directory.")]
    NoDataRootPath,
}

impl ConductorError {
    /// promote a custom error type to a ConductorError
    pub fn other(e: impl Into<Box<dyn std::error::Error + Send + Sync>>) -> Self {
        Self::Other(e.into())
    }
}

impl From<one_err::OneErr> for ConductorError {
    fn from(e: one_err::OneErr) -> Self {
        Self::other(e)
    }
}

impl From<ConductorError> for WasmErrorInner {
    fn from(e: ConductorError) -> Self {
        Self::Host(e.to_string())
    }
}