docker-registry-client 0.2.0

Communicate with Docker Registries to fetch image metadata.
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

use either::Either;

pub mod digest;
pub mod tag;

use digest::Digest;
use tag::Tag;

#[derive(Debug)]
pub enum FromStrError {
    MissingNameDigest,
    MissingNameTag,
    MissingDigest,
    ParseDigest(digest::FromStrError),
    ParseTag(tag::FromStrError),
}

#[derive(Debug, PartialEq, Clone, Eq, Hash)]
pub struct ImageName {
    pub name: String,
    pub identifier: Either<Tag, Digest>,
}

impl std::fmt::Display for FromStrError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::MissingNameDigest => f.write_str("missing name and digest"),
            Self::MissingNameTag => f.write_str("missing name and tag"),
            Self::MissingDigest => f.write_str("missing digest"),
            Self::ParseDigest(e) => write!(f, "error parsing digest: {e}"),
            Self::ParseTag(e) => write!(f, "error parsing tag: {e}"),
        }
    }
}

impl std::error::Error for FromStrError {}

impl std::fmt::Display for ImageName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{image_name}:{identifier}",
            image_name = self.name,
            identifier = match &self.identifier {
                Either::Left(tag) => tag.to_string(),
                Either::Right(digest) => digest.to_string(),
            }
        )
    }
}

impl std::str::FromStr for ImageName {
    type Err = FromStrError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let has_digest = s.contains('@');

        if has_digest {
            let parts: Vec<&str> = s.split('@').collect();
            let name = (*parts.first().ok_or(Self::Err::MissingNameDigest)?).to_string();

            let digest = parts
                .get(1)
                .ok_or(Self::Err::MissingDigest)?
                .parse()
                .map_err(Self::Err::ParseDigest)?;

            Ok(Self {
                name,
                identifier: Either::Right(digest),
            })
        } else {
            let parts: Vec<&str> = s.split(':').collect();
            let name = (*parts.first().ok_or(Self::Err::MissingNameTag)?).to_string();

            let tag = parts
                .get(1)
                .unwrap_or(&"latest")
                .parse()
                .map_err(Self::Err::ParseTag)?;

            Ok(Self {
                name,
                identifier: Either::Left(tag),
            })
        }
    }
}