move MonolithDiscoverer trait and implementations to ott-common crate

Author: dyc3

Cargo.lock

@@ -33,6 +33,7 @@ tokio-tungstenite = "0.21.0"
 tokio-util = "0.7.8"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.17"
+trust-dns-resolver = { version = "0.22.0", features = ["system-config"] }
 tungstenite = "0.21.0"
 typeshare = "1.0.0"
 url = "2.3.1"

Cargo.toml

@@ -33,7 +33,7 @@ route-recognizer = "0.3.1"
 once_cell.workspace = true
 pin-project.workspace = true
 prometheus.workspace = true
-trust-dns-resolver = { version = "0.22.0", features = ["system-config"] }
+trust-dns-resolver.workspace = true
 
 [dev-dependencies]
 criterion.workspace = true

crates/ott-balancer/Cargo.toml

@@ -1,88 +1,8 @@
-//! Handles discovery of Monoliths.
+use std::{collections::HashSet, time::Duration};
 
-use std::net::IpAddr;
-use std::time::Duration;
-use std::{collections::HashSet, net::SocketAddr};
-
-mod dns;
-mod fly;
-mod harness;
-mod manual;
-
-pub use dns::*;
-pub use fly::*;
-pub use harness::*;
-pub use manual::*;
-
-use async_trait::async_trait;
-use serde::Deserialize;
+pub use ott_common::discovery::*;
 use tokio::task::JoinHandle;
 use tracing::{debug, error, warn};
-use url::Url;
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize)]
-pub struct MonolithConnectionConfig {
-    pub host: HostOrIp,
-    pub port: u16,
-}
-
-impl MonolithConnectionConfig {
-    pub fn uri(&self) -> Url {
-        let mut url = Url::parse("ws://localhost").unwrap();
-        match self.host {
-            HostOrIp::Host(ref host) => {
-                url.set_host(Some(host)).unwrap();
-            }
-            HostOrIp::Ip(ip) => {
-                url.set_ip_host(ip).unwrap();
-            }
-        }
-        url.set_port(Some(self.port)).unwrap();
-
-        url
-    }
-}
-
-impl From<SocketAddr> for MonolithConnectionConfig {
-    fn from(addr: SocketAddr) -> Self {
-        Self {
-            host: HostOrIp::Ip(addr.ip()),
-            port: addr.port(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum HostOrIp {
-    Host(String),
-    Ip(IpAddr),
-}
-
-impl<'de> Deserialize<'de> for HostOrIp {
-    fn deserialize<D>(deserializer: D) -> Result<HostOrIp, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        if let Ok(ip) = s.parse::<IpAddr>() {
-            Ok(HostOrIp::Ip(ip))
-        } else {
-            Ok(HostOrIp::Host(s))
-        }
-    }
-}
-
-#[async_trait]
-pub trait MonolithDiscoverer {
-    /// In polling mode, this function should immediately return the current list of monoliths. In continuous mode, this function should wait until the list of monoliths changes, then return the new list.
-    async fn discover(&mut self) -> anyhow::Result<Vec<MonolithConnectionConfig>>;
-    fn mode(&self) -> DiscoveryMode;
-}
-
-pub enum DiscoveryMode {
-    Polling(Duration),
-    Continuous,
-}
 
 pub struct DiscoveryTask {
     discovery: Box<dyn MonolithDiscoverer + Send + Sync>,

crates/ott-balancer/src/discovery.rs

@@ -4,15 +4,22 @@ version = "0.10.0"
 edition = "2021"
 
 [dependencies]
+anyhow.workspace = true
 async-trait.workspace = true
 futures-util.workspace = true
 hyper.workspace = true
 hyper-util.workspace = true
 http-body-util.workspace = true
+ott-balancer-protocol.workspace = true
 pin-project.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_path_to_error.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 tokio.workspace = true
 tokio-tungstenite.workspace = true
 tokio-util.workspace = true
+trust-dns-resolver.workspace = true
 tungstenite.workspace = true
+url.workspace = true

crates/ott-common/Cargo.toml

@@ -0,0 +1,84 @@
+//! Handles discovery of Monoliths.
+
+use std::net::IpAddr;
+use std::net::SocketAddr;
+use std::time::Duration;
+
+mod dns;
+mod fly;
+mod harness;
+mod manual;
+
+pub use dns::*;
+pub use fly::*;
+pub use harness::*;
+pub use manual::*;
+
+use async_trait::async_trait;
+use serde::Deserialize;
+use tokio::task::JoinHandle;
+use url::Url;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize)]
+pub struct MonolithConnectionConfig {
+    pub host: HostOrIp,
+    pub port: u16,
+}
+
+impl MonolithConnectionConfig {
+    pub fn uri(&self) -> Url {
+        let mut url = Url::parse("ws://localhost").unwrap();
+        match self.host {
+            HostOrIp::Host(ref host) => {
+                url.set_host(Some(host)).unwrap();
+            }
+            HostOrIp::Ip(ip) => {
+                url.set_ip_host(ip).unwrap();
+            }
+        }
+        url.set_port(Some(self.port)).unwrap();
+
+        url
+    }
+}
+
+impl From<SocketAddr> for MonolithConnectionConfig {
+    fn from(addr: SocketAddr) -> Self {
+        Self {
+            host: HostOrIp::Ip(addr.ip()),
+            port: addr.port(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HostOrIp {
+    Host(String),
+    Ip(IpAddr),
+}
+
+impl<'de> Deserialize<'de> for HostOrIp {
+    fn deserialize<D>(deserializer: D) -> Result<HostOrIp, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        if let Ok(ip) = s.parse::<IpAddr>() {
+            Ok(HostOrIp::Ip(ip))
+        } else {
+            Ok(HostOrIp::Host(s))
+        }
+    }
+}
+
+#[async_trait]
+pub trait MonolithDiscoverer {
+    /// In polling mode, this function should immediately return the current list of monoliths. In continuous mode, this function should wait until the list of monoliths changes, then return the new list.
+    async fn discover(&mut self) -> anyhow::Result<Vec<MonolithConnectionConfig>>;
+    fn mode(&self) -> DiscoveryMode;
+}
+
+pub enum DiscoveryMode {
+    Polling(Duration),
+    Continuous,
+}

crates/ott-common/src/discovery.rs

@@ -1 +1,2 @@
+pub mod discovery;
 pub mod websocket;