RUST-760 Refactor the StreamAddress struct to ServerAddress enum (#339)

Author: patrickfreed

src/client/mod.rs

@@ -10,7 +10,7 @@ use derivative::Derivative;
 use std::time::Instant;
 
 #[cfg(test)]
-use crate::options::StreamAddress;
+use crate::options::ServerAddress;
 use crate::{
     bson::Document,
     concern::{ReadConcern, WriteConcern},
@@ -263,7 +263,7 @@ impl Client {
     pub(crate) async fn test_select_server(
         &self,
         criteria: Option<&SelectionCriteria>,
-    ) -> Result<StreamAddress> {
+    ) -> Result<ServerAddress> {
         let server = self.select_server(criteria).await?;
         Ok(server.address.clone())
     }

src/client/options/mod.rs

@@ -101,6 +101,8 @@ lazy_static! {
 
 /// A hostname:port address pair.
 #[derive(Clone, Debug, Eq)]
+#[deprecated = "This type has been renamed to `ServerAddress` and will be removed in the 2.0.0 \
+                stable release"]
 pub struct StreamAddress {
     /// The hostname of the address.
     pub hostname: String,
@@ -111,7 +113,44 @@ pub struct StreamAddress {
     pub port: Option<u16>,
 }
 
-impl<'de> Deserialize<'de> for StreamAddress {
+#[allow(deprecated)]
+impl PartialEq for StreamAddress {
+    fn eq(&self, other: &Self) -> bool {
+        self.hostname == other.hostname && self.port.unwrap_or(27017) == other.port.unwrap_or(27017)
+    }
+}
+
+#[allow(deprecated)]
+impl Hash for StreamAddress {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.hostname.hash(state);
+        self.port.unwrap_or(27017).hash(state);
+    }
+}
+
+/// An enum representing the address of a MongoDB server.
+///
+/// Currently this just supports addresses that can be connected to over TCP, but alternative
+/// address types may be supported in the future (e.g. Unix Domain Socket paths).
+#[derive(Clone, Debug, Eq)]
+#[non_exhaustive]
+pub enum ServerAddress {
+    /// A TCP/IP host and port combination.
+    Tcp {
+        /// The hostname or IP address where the MongoDB server can be found.
+        host: String,
+
+        /// The TCP port that the MongoDB server is listening on.
+        ///
+        /// The default is 27017.
+        port: Option<u16>,
+    },
+}
+
+impl<'de> Deserialize<'de> for ServerAddress {
     fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -121,32 +160,54 @@ impl<'de> Deserialize<'de> for StreamAddress {
     }
 }
 
-impl Default for StreamAddress {
+impl Default for ServerAddress {
     fn default() -> Self {
-        Self {
-            hostname: "localhost".into(),
+        Self::Tcp {
+            host: "localhost".into(),
             port: None,
         }
     }
 }
 
-impl PartialEq for StreamAddress {
+impl PartialEq for ServerAddress {
     fn eq(&self, other: &Self) -> bool {
-        self.hostname == other.hostname && self.port.unwrap_or(27017) == other.port.unwrap_or(27017)
+        match (self, other) {
+            (
+                Self::Tcp { host, port },
+                Self::Tcp {
+                    host: other_host,
+                    port: other_port,
+                },
+            ) => host == other_host && port.unwrap_or(27017) == other_port.unwrap_or(27017),
+        }
     }
 }
 
-impl Hash for StreamAddress {
+impl Hash for ServerAddress {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
-        self.hostname.hash(state);
-        self.port.unwrap_or(27017).hash(state);
+        match self {
+            Self::Tcp { host, port } => {
+                host.hash(state);
+                port.unwrap_or(27017).hash(state);
+            }
+        }
     }
 }
 
-impl StreamAddress {
+#[allow(deprecated)]
+impl From<StreamAddress> for ServerAddress {
+    fn from(sa: StreamAddress) -> Self {
+        Self::Tcp {
+            host: sa.hostname,
+            port: sa.port,
+        }
+    }
+}
+
+impl ServerAddress {
     /// Parses an address string into a `StreamAddress`.
     pub fn parse(address: impl AsRef<str>) -> Result<Self> {
         let address = address.as_ref();
@@ -186,36 +247,44 @@ impl StreamAddress {
             None => None,
         };
 
-        Ok(StreamAddress {
-            hostname: hostname.to_string(),
+        Ok(ServerAddress::Tcp {
+            host: hostname.to_string(),
             port,
         })
     }
 
     #[cfg(all(test, not(feature = "sync")))]
-    pub(crate) fn into_document(mut self) -> Document {
-        let mut doc = Document::new();
-
-        doc.insert("host", &self.hostname);
+    pub(crate) fn into_document(self) -> Document {
+        match self {
+            Self::Tcp { host, port } => {
+                doc! {
+                    "host": host,
+                    "port": port.map(|i| Bson::Int32(i.into())).unwrap_or(Bson::Null)
+                }
+            }
+        }
+    }
 
-        if let Some(i) = self.port.take() {
-            doc.insert("port", i32::from(i));
-        } else {
-            doc.insert("port", Bson::Null);
+    pub(crate) fn host(&self) -> &str {
+        match self {
+            Self::Tcp { host, .. } => host.as_str(),
         }
+    }
 
-        doc
+    pub(crate) fn port(&self) -> Option<u16> {
+        match self {
+            Self::Tcp { port, .. } => *port,
+        }
     }
 }
 
-impl fmt::Display for StreamAddress {
+impl fmt::Display for ServerAddress {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "{}:{}",
-            self.hostname,
-            self.port.unwrap_or(DEFAULT_PORT)
-        )
+        match self {
+            Self::Tcp { host, port } => {
+                write!(fmt, "{}:{}", host, port.unwrap_or(DEFAULT_PORT))
+            }
+        }
     }
 }
 
@@ -291,12 +360,12 @@ pub struct ClientOptions {
     /// Note that by default, the driver will autodiscover other nodes in the cluster. To connect
     /// directly to a single server (rather than autodiscovering the rest of the cluster), set the
     /// `direct` field to `true`.
-    #[builder(default_code = "vec![ StreamAddress {
-        hostname: \"localhost\".to_string(),
+    #[builder(default_code = "vec![ServerAddress::Tcp {
+        host: \"localhost\".to_string(),
         port: Some(27017),
     }]")]
     #[serde(default = "default_hosts")]
-    pub hosts: Vec<StreamAddress>,
+    pub hosts: Vec<ServerAddress>,
 
     /// The application name that the Client will send to the server as part of the handshake. This
     /// can be used in combination with the server logs to determine which Client is connected to a
@@ -472,11 +541,8 @@ pub struct ClientOptions {
     pub(crate) heartbeat_freq_test: Option<Duration>,
 }
 
-fn default_hosts() -> Vec<StreamAddress> {
-    vec![StreamAddress {
-        hostname: "localhost".to_string(),
-        port: Some(27017),
-    }]
+fn default_hosts() -> Vec<ServerAddress> {
+    vec![ServerAddress::default()]
 }
 
 impl Default for ClientOptions {
@@ -487,7 +553,7 @@ impl Default for ClientOptions {
 
 #[derive(Debug, Default, PartialEq)]
 struct ClientOptionsParser {
-    pub hosts: Vec<StreamAddress>,
+    pub hosts: Vec<ServerAddress>,
     pub srv: bool,
     pub app_name: Option<String>,
     pub tls: Option<Tls>,
@@ -825,11 +891,11 @@ impl ClientOptions {
         if srv {
             let mut resolver = SrvResolver::new(resolver_config.map(|config| config.inner)).await?;
             let mut config = resolver
-                .resolve_client_options(&options.hosts[0].hostname)
+                .resolve_client_options(&options.hosts[0].host())
                 .await?;
 
             // Save the original SRV hostname to allow mongos polling.
-            options.original_srv_hostname = Some(options.hosts[0].hostname.clone());
+            options.original_srv_hostname = Some(options.hosts[0].host().to_string());
 
             // Set the ClientOptions hosts to those found during the SRV lookup.
             options.hosts = config.hosts;
@@ -1123,8 +1189,8 @@ impl ClientOptionsParser {
                     Some(p)
                 };
 
-                Ok(StreamAddress {
-                    hostname: hostname.to_lowercase(),
+                Ok(ServerAddress::Tcp {
+                    host: hostname.to_lowercase(),
                     port,
                 })
             })
@@ -1140,7 +1206,7 @@ impl ClientOptionsParser {
                 .into());
             }
 
-            if hosts[0].port.is_some() {
+            if hosts[0].port().is_some() {
                 return Err(ErrorKind::InvalidArgument {
                     message: "a port cannot be specified with 'mongodb+srv'".into(),
                 }
@@ -1722,7 +1788,7 @@ mod tests {
 
     use pretty_assertions::assert_eq;
 
-    use super::{ClientOptions, StreamAddress};
+    use super::{ClientOptions, ServerAddress};
     use crate::{
         concern::{Acknowledgment, ReadConcernLevel, WriteConcern},
         selection_criteria::{ReadPreference, ReadPreferenceOptions},
@@ -1745,9 +1811,9 @@ mod tests {
         }
     }
 
-    fn host_without_port(hostname: &str) -> StreamAddress {
-        StreamAddress {
-            hostname: hostname.to_string(),
+    fn host_without_port(hostname: &str) -> ServerAddress {
+        ServerAddress::Tcp {
+            host: hostname.to_string(),
             port: None,
         }
     }
@@ -1822,8 +1888,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 original_uri: Some(uri.into()),
@@ -1840,8 +1906,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 original_uri: Some(uri.into()),
@@ -1858,8 +1924,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 read_concern: Some(ReadConcernLevel::Custom("foo".to_string()).into()),
@@ -1886,8 +1952,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 write_concern: Some(write_concern),
@@ -1908,8 +1974,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 write_concern: Some(write_concern),
@@ -1938,8 +2004,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 write_concern: Some(write_concern),
@@ -1980,8 +2046,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 write_concern: Some(write_concern),
@@ -2004,8 +2070,8 @@ mod tests {
         assert_eq!(
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
-                hosts: vec![StreamAddress {
-                    hostname: "localhost".to_string(),
+                hosts: vec![ServerAddress::Tcp {
+                    host: "localhost".to_string(),
                     port: Some(27017),
                 }],
                 write_concern: Some(write_concern),
@@ -2037,12 +2103,12 @@ mod tests {
             ClientOptions::parse(uri).await.unwrap(),
             ClientOptions {
                 hosts: vec![
-                    StreamAddress {
-                        hostname: "localhost".to_string(),
+                    ServerAddress::Tcp {
+                        host: "localhost".to_string(),
                         port: None,
                     },
-                    StreamAddress {
-                        hostname: "localhost".to_string(),
+                    ServerAddress::Tcp {
+                        host: "localhost".to_string(),
                         port: Some(27018),
                     },
                 ],