compose_spec 0.3.0

Types for (de)serializing from/to the compose-spec
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
106
107
108
109
110
111
112
113
114

//! Provides [`EndpointMode`] for the `endpoint_mode` field of [`Deploy`](super::Deploy).

use std::{
    borrow::Cow,
    fmt::{self, Display, Formatter},
};

use compose_spec_macros::{DeserializeTryFromString, SerializeDisplay};

use crate::impl_from_str;

/// [`Service`](crate::Service) discovery method for external clients connecting to a service.
///
/// Default and available values are platform specific, however, the specification defines two
/// canonical values: [`vip`](Self::VIp) and [`dnsrr`](Self::DnsRR).
///
/// [compose-spec](https://github.com/compose-spec/compose-spec/blob/master/deploy.md#endpoint_mode)
#[derive(SerializeDisplay, DeserializeTryFromString, Debug, Clone, PartialEq, Eq)]
pub enum EndpointMode {
    /// Assigns the service a virtual IP (VIP) that acts as the front end for clients to reach the
    /// service on a network. The platform routes requests between the client and nodes running the
    /// service, without the client knowing how many nodes are participating in the service or their
    /// IP addresses or ports.
    VIp,

    /// The platform sets up DNS entries for the service such that a DNS query for the service name
    /// returns a list of IP addresses (DNS round-robin), and the client connects directly to one of
    /// these.
    DnsRR,

    /// Some other endpoint mode.
    Other(String),
}

impl EndpointMode {
    /// [`Self::VIp`] string value.
    const VIP: &'static str = "vip";

    /// [`Self::DnsRR`] string value.
    const DNS_RR: &'static str = "dnsrr";

    /// Parse an [`EndpointMode`] from a string.
    pub fn parse<T>(endpoint_mode: T) -> Self
    where
        T: AsRef<str> + Into<String>,
    {
        match endpoint_mode.as_ref() {
            Self::VIP => Self::VIp,
            Self::DNS_RR => Self::DnsRR,
            _ => Self::Other(endpoint_mode.into()),
        }
    }

    /// Returns `true` if the endpoint mode is [`VIp`].
    ///
    /// [`VIp`]: EndpointMode::VIp
    #[must_use]
    pub const fn is_vip(&self) -> bool {
        matches!(self, Self::VIp)
    }

    /// Returns `true` if the endpoint mode is [`DnsRR`].
    ///
    /// [`DnsRR`]: EndpointMode::DnsRR
    #[must_use]
    pub const fn is_dnsrr(&self) -> bool {
        matches!(self, Self::DnsRR)
    }

    /// Endpoint mode as a string slice.
    ///
    /// Convenience method for `as_ref()` to a `&str`.
    #[must_use]
    pub fn as_str(&self) -> &str {
        match self {
            Self::VIp => Self::VIP,
            Self::DnsRR => Self::DNS_RR,
            Self::Other(other) => other,
        }
    }
}

impl_from_str!(EndpointMode);

impl AsRef<str> for EndpointMode {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl Display for EndpointMode {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<EndpointMode> for String {
    fn from(value: EndpointMode) -> Self {
        match value {
            EndpointMode::VIp | EndpointMode::DnsRR => value.as_str().to_owned(),
            EndpointMode::Other(string) => string,
        }
    }
}

impl From<EndpointMode> for Cow<'static, str> {
    fn from(value: EndpointMode) -> Self {
        match value {
            EndpointMode::VIp => Self::Borrowed(EndpointMode::VIP),
            EndpointMode::DnsRR => Self::Borrowed(EndpointMode::DNS_RR),
            EndpointMode::Other(other) => Self::Owned(other),
        }
    }
}