oci-zero 0.1.0

A no-std, allocation-free streaming core for OCI registries
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

use std::{
    error::Error, ffi::OsString, fmt, io, path::PathBuf, process::ExitStatus, string::String,
};

/// Failure to read Docker configuration or obtain a configured credential.
#[derive(Debug)]
pub enum DockerCredentialError {
    ReadConfig {
        path: PathBuf,
        source: io::Error,
    },
    ParseConfig(serde_json::Error),
    ParseEnvironmentConfig(serde_json::Error),
    EnvironmentNotUnicode,
    InvalidAuth {
        registry: String,
    },
    InvalidHelperName {
        helper: String,
    },
    RunHelper {
        program: OsString,
        source: io::Error,
    },
    MissingHelperInput {
        program: OsString,
    },
    HelperFailed {
        program: OsString,
        status: ExitStatus,
    },
    InvalidHelperResponse {
        program: OsString,
        source: serde_json::Error,
    },
    MissingHelperUsername {
        program: OsString,
    },
}

impl fmt::Display for DockerCredentialError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::ReadConfig { path, .. } => {
                write!(
                    formatter,
                    "could not read Docker config at {}",
                    path.display()
                )
            }
            Self::ParseConfig(_) => formatter.write_str("Docker config is not valid JSON"),
            Self::ParseEnvironmentConfig(_) => {
                formatter.write_str("DOCKER_AUTH_CONFIG is not valid Docker auth JSON")
            }
            Self::EnvironmentNotUnicode => {
                formatter.write_str("DOCKER_AUTH_CONFIG is not valid Unicode")
            }
            Self::InvalidAuth { registry } => {
                write!(formatter, "Docker auth entry for {registry} is invalid")
            }
            Self::InvalidHelperName { helper } => {
                write!(
                    formatter,
                    "Docker credential helper name {helper:?} is invalid"
                )
            }
            Self::RunHelper { program, .. } => {
                write!(
                    formatter,
                    "could not run Docker credential helper {program:?}"
                )
            }
            Self::MissingHelperInput { program } => {
                write!(
                    formatter,
                    "Docker credential helper {program:?} has no input pipe"
                )
            }
            Self::HelperFailed { program, status } => write!(
                formatter,
                "Docker credential helper {program:?} failed with {status}"
            ),
            Self::InvalidHelperResponse { program, .. } => write!(
                formatter,
                "Docker credential helper {program:?} returned invalid JSON"
            ),
            Self::MissingHelperUsername { program } => write!(
                formatter,
                "Docker credential helper {program:?} returned an empty username"
            ),
        }
    }
}

impl Error for DockerCredentialError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::ReadConfig { source, .. } | Self::RunHelper { source, .. } => Some(source),
            Self::ParseConfig(source)
            | Self::ParseEnvironmentConfig(source)
            | Self::InvalidHelperResponse { source, .. } => Some(source),
            _ => None,
        }
    }
}