mitoxide 0.1.0

Rust library for remote execution and automation inspired by Mitogen
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

//! Error types for the Mitoxide library

use thiserror::Error;
use std::time::Duration;

/// Main error type for Mitoxide operations
#[derive(Debug, Error)]
pub enum MitoxideError {
    /// Transport-related errors
    #[error("Transport error: {0}")]
    Transport(String),
    
    /// Protocol-related errors  
    #[error("Protocol error: {0}")]
    Protocol(String),
    
    /// Agent-related errors
    #[error("Agent error: {0}")]
    Agent(String),
    
    /// Authentication errors
    #[error("Authentication error: {0}")]
    Auth(String),
    
    /// Timeout errors
    #[error("Timeout after {duration:?}")]
    Timeout { 
        /// Duration that was exceeded
        duration: Duration 
    },
    
    /// WASM execution errors
    #[cfg(feature = "wasm")]
    #[error("WASM execution error: {0}")]
    Wasm(String),
    
    /// I/O errors
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
    
    /// Serialization errors
    #[error("Serialization error: {0}")]
    Serialization(String),
    
    /// Connection errors
    #[error("Connection error: {0}")]
    Connection(String),
    
    /// Session errors
    #[error("Session error: {0}")]
    Session(String),
}

impl From<mitoxide_ssh::TransportError> for MitoxideError {
    fn from(err: mitoxide_ssh::TransportError) -> Self {
        match err {
            mitoxide_ssh::TransportError::Connection(msg) => Self::Connection(msg),
            mitoxide_ssh::TransportError::Bootstrap(msg) => Self::Agent(msg),
            mitoxide_ssh::TransportError::Protocol(msg) => Self::Protocol(msg),
            mitoxide_ssh::TransportError::Io(e) => Self::Io(e),
            mitoxide_ssh::TransportError::Authentication(msg) => Self::Auth(msg),
            mitoxide_ssh::TransportError::Timeout => Self::Timeout { duration: Duration::from_secs(30) },
            mitoxide_ssh::TransportError::Configuration(msg) => Self::Protocol(msg),
            mitoxide_ssh::TransportError::CommandFailed { .. } => Self::Agent("Command failed".to_string()),
        }
    }
}

impl From<rmp_serde::encode::Error> for MitoxideError {
    fn from(err: rmp_serde::encode::Error) -> Self {
        Self::Serialization(format!("MessagePack encode error: {}", err))
    }
}

impl From<rmp_serde::decode::Error> for MitoxideError {
    fn from(err: rmp_serde::decode::Error) -> Self {
        Self::Serialization(format!("MessagePack decode error: {}", err))
    }
}

impl From<serde_json::Error> for MitoxideError {
    fn from(err: serde_json::Error) -> Self {
        Self::Serialization(format!("JSON error: {}", err))
    }
}