Rename Host -> HostName

Author: sbernauer

crates/stackable-operator/CHANGELOG.md

@@ -6,11 +6,12 @@ All notable changes to this project will be documented in this file.
 
 ### Added
 
-- BREAKING: Add `Host` type and use it within LDAP and OIDC AuthenticationClass as well as S3Connection ([#863]).
+- BREAKING: Add `HostName` type and use it within LDAP and OIDC AuthenticationClass as well as S3Connection ([#863]).
 
 ### Changed
 
 - BREAKING: TLS verification struct now reside in the `commons::tls_verification` module, instead of being placed below `commons::authentication::tls` ([#863]).
+- BREAKING: Rename the `Hostname` type to `DomainName` to be consistent with RFC 1123 ([#863]).
 
 ### Fixed
 

crates/stackable-operator/src/commons/authentication/ldap.rs

@@ -8,7 +8,7 @@ use crate::{
     builder::pod::{container::ContainerBuilder, volume::VolumeMountBuilder, PodBuilder},
     commons::{
         authentication::SECRET_BASE_PATH,
-        networking::Host,
+        networking::HostName,
         secret_class::{SecretClassVolume, SecretClassVolumeError},
         tls_verification::{TlsClientDetails, TlsClientDetailsError},
     },
@@ -36,7 +36,7 @@ pub enum Error {
 #[serde(rename_all = "camelCase")]
 pub struct AuthenticationProvider {
     /// Host of the LDAP server, for example: `my.ldap.server` or `127.0.0.1`.
-    pub hostname: Host,
+    pub hostname: HostName,
 
     /// Port of the LDAP server. If TLS is used defaults to 636 otherwise to 389.
     port: Option<u16>,

crates/stackable-operator/src/commons/authentication/oidc.rs

@@ -12,7 +12,7 @@ use url::{ParseError, Url};
 #[cfg(doc)]
 use crate::commons::authentication::AuthenticationClass;
 use crate::commons::{
-    authentication::SECRET_BASE_PATH, networking::Host, tls_verification::TlsClientDetails,
+    authentication::SECRET_BASE_PATH, networking::HostName, tls_verification::TlsClientDetails,
 };
 
 pub type Result<T, E = Error> = std::result::Result<T, E>;
@@ -43,7 +43,7 @@ pub enum Error {
 #[serde(rename_all = "camelCase")]
 pub struct AuthenticationProvider {
     /// Host of the identity provider, e.g. `my.keycloak.corp` or `127.0.0.1`.
-    hostname: Host,
+    hostname: HostName,
 
     /// Port of the identity provider. If TLS is used defaults to 443,
     /// otherwise to 80.
@@ -92,7 +92,7 @@ fn default_root_path() -> String {
 
 impl AuthenticationProvider {
     pub fn new(
-        hostname: Host,
+        hostname: HostName,
         port: Option<u16>,
         root_path: String,
         tls: TlsClientDetails,

crates/stackable-operator/src/commons/networking.rs

@@ -6,43 +6,43 @@ use snafu::Snafu;
 
 use crate::validation;
 
-/// A validated hostname type conforming to RFC 1123, e.g. not an IPv6 address.
+/// A validated domain name type conforming to RFC 1123, e.g. an IPv4, but not an IPv6 address.
 #[derive(
     Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd, JsonSchema,
 )]
 #[serde(try_from = "String", into = "String")]
-pub struct Hostname(#[validate(regex(path = "validation::RFC_1123_SUBDOMAIN_REGEX"))] String);
+pub struct DomainName(#[validate(regex(path = "validation::RFC_1123_SUBDOMAIN_REGEX"))] String);
 
-impl FromStr for Hostname {
+impl FromStr for DomainName {
     type Err = validation::Errors;
 
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         validation::is_rfc_1123_subdomain(value)?;
-        Ok(Hostname(value.to_owned()))
+        Ok(DomainName(value.to_owned()))
     }
 }
 
-impl TryFrom<String> for Hostname {
+impl TryFrom<String> for DomainName {
     type Error = validation::Errors;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
         value.parse()
     }
 }
 
-impl From<Hostname> for String {
-    fn from(value: Hostname) -> Self {
+impl From<DomainName> for String {
+    fn from(value: DomainName) -> Self {
         value.0
     }
 }
 
-impl Display for Hostname {
+impl Display for DomainName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&self.0)
     }
 }
 
-impl Deref for Hostname {
+impl Deref for DomainName {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -51,82 +51,82 @@ impl Deref for Hostname {
 }
 
 #[derive(Debug, Snafu)]
-pub enum HostParseError {
+pub enum HostNameParseError {
     #[snafu(display(
-        "the given host '{host}' is not a valid host, which needs to be either a hostname or IP address"
+        "the given hostname '{hostname}' is not a valid hostname, which needs to be either a domain name or IP address"
     ))]
-    InvalidHost { host: String },
+    InvalidHostname { hostname: String },
 }
 
-/// A validated host (either a [`Hostname`] or IP address) type.
+/// A validated hostname (either a [`DomainName`] or IP address) type.
 #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 #[serde(try_from = "String", into = "String")]
-pub enum Host {
+pub enum HostName {
     IpAddress(IpAddr),
-    Hostname(Hostname),
+    DomainName(DomainName),
 }
 
-impl JsonSchema for Host {
+impl JsonSchema for HostName {
     fn schema_name() -> String {
-        "Host".to_owned()
+        "HostName".to_owned()
     }
 
     fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
         String::json_schema(gen)
     }
 }
 
-impl FromStr for Host {
-    type Err = HostParseError;
+impl FromStr for HostName {
+    type Err = HostNameParseError;
 
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         if let Ok(ip) = value.parse::<IpAddr>() {
-            return Ok(Host::IpAddress(ip));
+            return Ok(HostName::IpAddress(ip));
         }
 
-        if let Ok(hostname) = value.parse() {
-            return Ok(Host::Hostname(hostname));
+        if let Ok(domain_name) = value.parse() {
+            return Ok(HostName::DomainName(domain_name));
         };
 
-        InvalidHostSnafu {
-            host: value.to_owned(),
+        InvalidHostnameSnafu {
+            hostname: value.to_owned(),
         }
         .fail()
     }
 }
 
-impl TryFrom<String> for Host {
-    type Error = HostParseError;
+impl TryFrom<String> for HostName {
+    type Error = HostNameParseError;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
         value.parse()
     }
 }
 
-impl From<Host> for String {
-    fn from(value: Host) -> Self {
+impl From<HostName> for String {
+    fn from(value: HostName) -> Self {
         value.to_string()
     }
 }
 
-impl Display for Host {
+impl Display for HostName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Host::IpAddress(ip) => write!(f, "{ip}"),
-            Host::Hostname(hostname) => write!(f, "{hostname}"),
+            HostName::IpAddress(ip) => write!(f, "{ip}"),
+            HostName::DomainName(domain_name) => write!(f, "{domain_name}"),
         }
     }
 }
 
-impl Host {
+impl HostName {
     /// Formats the host in such a way that it can be used in URLs.
     pub fn as_url_host(&self) -> String {
         match self {
-            Host::IpAddress(ip) => match ip {
+            HostName::IpAddress(ip) => match ip {
                 IpAddr::V4(ip) => ip.to_string(),
                 IpAddr::V6(ip) => format!("[{ip}]"),
             },
-            Host::Hostname(hostname) => hostname.to_string(),
+            HostName::DomainName(domain_name) => domain_name.to_string(),
         }
     }
 }
@@ -176,37 +176,38 @@ mod tests {
     #[rstest]
     #[case("foo")]
     #[case("foo.bar")]
-    // Well this is also a valid hostname I guess
+    // This is also a valid domain name
     #[case("1.2.3.4")]
-    fn test_host_and_hostname_parsing_success(#[case] hostname: String) {
-        let parsed_hostname: Hostname = hostname.parse().expect("hostname can not be parsed");
-        // Every hostname is also a valid host
-        let parsed_host: Host = hostname.parse().expect("host can not be parsed");
+    fn test_domain_name_and_host_name_parsing_success(#[case] domain_name: String) {
+        let parsed_domain_name: DomainName =
+            domain_name.parse().expect("domain name can not be parsed");
+        // Every domain name is also a valid host name
+        let parsed_host_name: HostName = domain_name.parse().expect("host name can not be parsed");
 
         // Also test the round-trip
-        assert_eq!(parsed_hostname.to_string(), hostname);
-        assert_eq!(parsed_host.to_string(), hostname);
+        assert_eq!(parsed_domain_name.to_string(), domain_name);
+        assert_eq!(parsed_host_name.to_string(), domain_name);
     }
 
     #[rstest]
     #[case("")]
     #[case("foo.bar:1234")]
     #[case("fe80::1")]
-    fn test_hostname_parsing_invalid_input(#[case] hostname: &str) {
-        assert!(hostname.parse::<Hostname>().is_err());
+    fn test_domain_name_parsing_invalid_input(#[case] domain_name: &str) {
+        assert!(domain_name.parse::<DomainName>().is_err());
     }
 
     #[rstest]
     #[case("foo", "foo")]
     #[case("foo.bar", "foo.bar")]
     #[case("1.2.3.4", "1.2.3.4")]
     #[case("fe80::1", "[fe80::1]")]
-    fn test_host_parsing_success(#[case] host: &str, #[case] expected_url_host: &str) {
-        let parsed_host: Host = host.parse().expect("host can not be parsed");
+    fn test_host_name_parsing_success(#[case] host: &str, #[case] expected_url_host: &str) {
+        let parsed_host_name: HostName = host.parse().expect("host can not be parsed");
 
         // Also test the round-trip
-        assert_eq!(parsed_host.to_string(), host);
+        assert_eq!(parsed_host_name.to_string(), host);
 
-        assert_eq!(parsed_host.as_url_host(), expected_url_host);
+        assert_eq!(parsed_host_name.as_url_host(), expected_url_host);
     }
 }

crates/stackable-operator/src/commons/s3/crd.rs

@@ -3,7 +3,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::commons::{
-    networking::Host, secret_class::SecretClassVolume, tls_verification::TlsClientDetails,
+    networking::HostName, secret_class::SecretClassVolume, tls_verification::TlsClientDetails,
 };
 
 use super::S3ConnectionInlineOrReference;
@@ -50,7 +50,7 @@ pub struct S3BucketSpec {
 #[serde(rename_all = "camelCase")]
 pub struct S3ConnectionSpec {
     /// Host of the S3 server without any protocol or port. For example: `west1.my-cloud.com`.
-    pub host: Host,
+    pub host: HostName,
 
     /// Port the S3 server listens on.
     /// If not specified the product will determine the port to use.