herolib-virt 0.3.13

Virtualization and container management for herolib (buildah, nerdctl, kubernetes)
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 SAL Kubernetes operations

use thiserror::Error;

/// Errors that can occur during Kubernetes operations
#[derive(Error, Debug)]
pub enum KubernetesError {
    /// Kubernetes API client error
    #[error("Kubernetes API error: {0}")]
    ApiError(#[from] kube::Error),

    /// Configuration error
    #[error("Configuration error: {0}")]
    ConfigError(String),

    /// Resource not found error
    #[error("Resource not found: {0}")]
    ResourceNotFound(String),

    /// Invalid resource name or pattern
    #[error("Invalid resource name or pattern: {0}")]
    InvalidResourceName(String),

    /// Regular expression error
    #[error("Regular expression error: {0}")]
    RegexError(#[from] regex::Error),

    /// Serialization/deserialization error
    #[error("Serialization error: {0}")]
    SerializationError(#[from] serde_json::Error),

    /// YAML parsing error
    #[error("YAML error: {0}")]
    YamlError(#[from] serde_yaml::Error),

    /// Generic operation error
    #[error("Operation failed: {0}")]
    OperationError(String),

    /// Namespace error
    #[error("Namespace error: {0}")]
    NamespaceError(String),

    /// Permission denied error
    #[error("Permission denied: {0}")]
    PermissionDenied(String),

    /// Timeout error
    #[error("Operation timed out: {0}")]
    Timeout(String),

    /// Generic error wrapper
    #[error("Generic error: {0}")]
    Generic(#[from] anyhow::Error),
}

impl KubernetesError {
    /// Create a new configuration error
    pub fn config_error(msg: impl Into<String>) -> Self {
        Self::ConfigError(msg.into())
    }

    /// Create a new operation error
    pub fn operation_error(msg: impl Into<String>) -> Self {
        Self::OperationError(msg.into())
    }

    /// Create a new namespace error
    pub fn namespace_error(msg: impl Into<String>) -> Self {
        Self::NamespaceError(msg.into())
    }

    /// Create a new permission denied error
    pub fn permission_denied(msg: impl Into<String>) -> Self {
        Self::PermissionDenied(msg.into())
    }

    /// Create a new timeout error
    pub fn timeout(msg: impl Into<String>) -> Self {
        Self::Timeout(msg.into())
    }
}

/// Result type for Kubernetes operations
pub type KubernetesResult<T> = Result<T, KubernetesError>;