move router from server to a dependent crate.

cluster/Cargo.toml

@@ -11,7 +11,6 @@ workspace = true
 workspace = true
 
 [dependencies]
-analytic_engine = { workspace = true }
 async-trait = { workspace = true }
 ceresdbproto = { workspace = true }
 common_types = { workspace = true }

router/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "router"
+
+[package.version]
+workspace = true
+
+[package.authors]
+workspace = true
+
+[package.edition]
+workspace = true
+
+[dependencies]
+async-trait = { workspace = true }
+ceresdbproto = { workspace = true }
+cluster = { workspace = true }
+common_types = { workspace = true }
+common_util = { workspace = true }
+log = { workspace = true }
+meta_client = { workspace = true }
+serde = { workspace = true }
+serde_derive  = { workspace = true }
+snafu = { workspace = true }
+twox-hash = "1.6"

server/src/route/cluster_based.rs → router/src/cluster_based.rs

@@ -11,8 +11,7 @@ use meta_client::types::{NodeShard, RouteTablesRequest, RouteTablesResponse};
 use snafu::{OptionExt, ResultExt};
 
 use crate::{
-    config::Endpoint,
-    route::{hash, OtherNoCause, OtherWithCause, ParseEndpoint, Result, Router},
+    endpoint::Endpoint, hash, OtherNoCause, OtherWithCause, ParseEndpoint, Result, Router,
 };
 
 pub struct ClusterBasedRouter {

router/src/endpoint.rs

@@ -0,0 +1,67 @@
+// Copyright 2022 CeresDB Project Authors. Licensed under Apache-2.0.
+
+//! Endpoint definition
+
+use std::str::FromStr;
+
+use ceresdbproto::storage;
+use serde_derive::Deserialize;
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+pub struct Endpoint {
+    pub addr: String,
+    pub port: u16,
+}
+
+impl Endpoint {
+    pub fn new(addr: String, port: u16) -> Self {
+        Self { addr, port }
+    }
+}
+
+impl ToString for Endpoint {
+    fn to_string(&self) -> String {
+        format!("{}:{}", self.addr, self.port)
+    }
+}
+
+impl FromStr for Endpoint {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let (addr, raw_port) = match s.rsplit_once(':') {
+            Some(v) => v,
+            None => {
+                let err_msg = "Can't find ':' in the source string".to_string();
+                return Err(Self::Err::from(err_msg));
+            }
+        };
+        let port = raw_port.parse().map_err(|e| {
+            let err_msg = format!("Fail to parse port:{}, err:{}", raw_port, e);
+            Self::Err::from(err_msg)
+        })?;
+
+        Ok(Endpoint {
+            addr: addr.to_string(),
+            port,
+        })
+    }
+}
+
+impl From<Endpoint> for storage::Endpoint {
+    fn from(endpoint: Endpoint) -> Self {
+        storage::Endpoint {
+            ip: endpoint.addr,
+            port: endpoint.port as u32,
+        }
+    }
+}
+
+impl From<storage::Endpoint> for Endpoint {
+    fn from(endpoint_pb: storage::Endpoint) -> Self {
+        Endpoint {
+            addr: endpoint_pb.ip,
+            port: endpoint_pb.port as u16,
+        }
+    }
+}

server/src/route/mod.rs → router/src/lib.rs

@@ -1,15 +1,16 @@
 // Copyright 2022 CeresDB Project Authors. Licensed under Apache-2.0.
 
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use ceresdbproto::storage::{Route, RouteRequest};
-
 pub mod cluster_based;
+pub mod endpoint;
 pub(crate) mod hash;
 pub mod rule_based;
 
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use ceresdbproto::storage::{Route, RouteRequest};
 pub use cluster_based::ClusterBasedRouter;
+use common_util::define_result;
 pub use rule_based::{RuleBasedRouter, RuleList};
 use snafu::{Backtrace, Snafu};
 

server/src/route/rule_based.rs → router/src/rule_based.rs

@@ -12,10 +12,7 @@ use meta_client::types::ShardId;
 use serde_derive::Deserialize;
 use snafu::{ensure, OptionExt};
 
-use crate::{
-    config::Endpoint,
-    route::{hash, Result, RouteNotFound, Router, ShardNotFound},
-};
+use crate::{endpoint::Endpoint, hash, Result, RouteNotFound, Router, ShardNotFound};
 
 pub type ShardNodes = HashMap<ShardId, Endpoint>;
 

server/Cargo.toml

@@ -37,6 +37,7 @@ prometheus = { workspace = true }
 prometheus-static-metric = { workspace = true }
 prost = { workspace = true }
 query_engine = { workspace = true }
+router = { workspace = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 serde_json = { workspace = true }
@@ -47,8 +48,6 @@ table_engine = { workspace = true }
 tokio = { workspace = true }
 tokio-stream = { version = "0.1", features = ["net"] }
 tonic = { workspace = true }
-twox-hash = "1.6"
 warp = "0.3"
-
 [dev-dependencies]
 sql = { workspace = true, features = ["test"] }