Struct Reference 

pub struct Reference<'a> {
    pub registry: &'a str,
    pub repository: Repository<'a>,
    pub tag: &'a str,
    pub digest: Option<Digest>,
}

Reference to an image in an OCI registry.

The parser tries to be close to what docker pull does:

• If the reference does not include the hostname of the registry, it uses Docker Hub, and the repository namespace defaults to library if there is none. For example:

  • debian is parsed as registry-1.docker.io/library/debian.
  • nixos/nix is parsed as registry-1.docker.io/nixos/nix.

• It accepts any tag value after the last : character. If no tag is given, it uses latest.

• It accepts a fixed digest (the last part after a @ character), but only SHA256 and SHA512.

However, it does not try to be bug-for-bug compatible with Docker.

Examples

const REFERENCE: &str = "registry.example.com/foo/bar:1.23.4@sha256:123456789012345678901234567890123456789012345678901234567890ABCD";

let reference = Reference::try_from(REFERENCE).unwrap();
assert_eq!(reference.registry, "registry.example.com");
assert_eq!(reference.repository.namespace(), Some("foo"));
assert_eq!(reference.repository.name(), "bar");
assert_eq!(reference.tag, "1.23.4");

let digest = reference.digest.as_ref().unwrap();
assert_eq!(digest.algorithm(), DigestAlgorithm::SHA256);
assert_eq!(digest.hash_value(), "123456789012345678901234567890123456789012345678901234567890ABCD");

let reference = Reference::try_from("debian:stable").unwrap();

assert_eq!(reference.repository.to_string(), "library/debian");
assert_eq!(reference.tag, "stable");

Fields

registry: &'a str

Address of the registry server.

repository: Repository<'a>

Repository name.

tag: &'a str

Image tag.

digest: Option<Digest>

Manifest digest, if present.

Trait Implementations

impl<'a> Clone for Reference<'a>

fn clone(&self) -> Reference<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Reference<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for Reference<'a>

fn eq(&self, other: &Reference<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> TryFrom<&'a str> for Reference<'a>

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(reference: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for Reference<'a>