Splitting relay service and mega service

Cargo.toml

@@ -10,11 +10,12 @@ members = [
     "libra",
     "vault",
     "neptune",
+    "aries",
     "saturn",
     "lunar/src-tauri",
     "atlas",
 ]
-default-members = ["mega", "libra"]
+default-members = ["mega", "libra","aries"]
 exclude = ["craft"]
 resolver = "1"
 

aries/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "aries"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "aries"
+path = "src/main.rs"
+
+[dependencies]
+common = { workspace = true }
+callisto = { workspace = true }
+gemini = { workspace = true }
+jupiter = { workspace = true }
+tokio = { workspace = true }
+clap = { workspace = true, features = ["derive"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing-appender = { workspace = true }
+axum = { workspace = true }
+serde_json = { workspace = true }
+tower = { workspace = true }
+tower-http = { workspace = true, features = [
+    "cors",
+    "trace",
+    "decompression-full",
+] }
+ctrlc = "3.4.4"
+regex = "1.10.4"

aries/src/main.rs

@@ -0,0 +1,83 @@
+use clap::Parser;
+use common::config::{Config, LogConfig};
+use gemini::ztm::hub::LocalZTMHub;
+use service::{
+    ca_server::run_ca_server,
+    relay_server::{run_relay_server, RelayOptions},
+};
+use std::{env, thread, time};
+use tracing_subscriber::fmt::writer::MakeWriterExt;
+
+pub mod service;
+
+#[tokio::main]
+async fn main() {
+    // Get the current directory
+    let current_dir = env::current_dir().unwrap();
+    // Get the path to the config file in the current directory
+    let config_path = current_dir.join("config.toml");
+
+    let config = if config_path.exists() {
+        Config::new(config_path.to_str().unwrap()).unwrap()
+    } else {
+        eprintln!("can't find config.toml under {:?}, you can manually set config.toml path with --config parameter", env::current_dir().unwrap());
+        Config::default()
+    };
+
+    init_log(&config.log);
+
+    ctrlc::set_handler(move || {
+        tracing::info!("Received Ctrl-C signal, exiting...");
+        std::process::exit(0);
+    })
+    .unwrap();
+
+    let option = RelayOptions::parse();
+    tracing::info!("{:?}", option);
+
+    //Start a sub thread to ca server
+    let config_clone = config.clone();
+    let ca_port = option.ca_port;
+    tokio::spawn(async move { run_ca_server(config_clone, ca_port).await });
+    thread::sleep(time::Duration::from_secs(5));
+
+    //Start a sub thread to run ztm-hub
+    let ca = format!("127.0.0.1:{ca_port}");
+    let ztm_hub: LocalZTMHub = LocalZTMHub {
+        hub_port: option.ztm_hub_port,
+        ca,
+        name: vec!["relay".to_string()],
+    };
+    ztm_hub.clone().start_ztm_hub();
+    thread::sleep(time::Duration::from_secs(5));
+
+    //Start  relay server
+    run_relay_server(config, option).await;
+}
+
+fn init_log(config: &LogConfig) {
+    let log_level = match config.level.as_str() {
+        "trace" => tracing::Level::TRACE,
+        "debug" => tracing::Level::DEBUG,
+        "info" => tracing::Level::INFO,
+        "warn" => tracing::Level::WARN,
+        "error" => tracing::Level::ERROR,
+        _ => tracing::Level::INFO,
+    };
+
+    let file_appender =
+        tracing_appender::rolling::hourly(config.log_path.clone(), "mega-relay-logs");
+
+    if config.print_std {
+        let stdout = std::io::stdout;
+        tracing_subscriber::fmt()
+            .with_writer(stdout.and(file_appender))
+            .with_max_level(log_level)
+            .init();
+    } else {
+        tracing_subscriber::fmt()
+            .with_writer(file_appender)
+            .with_max_level(log_level)
+            .init();
+    }
+}

gateway/src/ca_server.rs → aries/src/service/ca_server.rs

@@ -15,10 +15,7 @@ use tower_http::cors::{Any, CorsLayer};
 use tower_http::decompression::RequestDecompressionLayer;
 use tower_http::trace::TraceLayer;
 
-use crate::api::api_router::{self};
-use crate::api::ApiServiceState;
-
-pub async fn run_ca_server(config: Config, _host: String, port: u16) {
+pub async fn run_ca_server(config: Config, port: u16) {
     let host = "127.0.0.1".to_string();
     let app = app(config.clone(), host.clone(), port).await;
 
@@ -45,15 +42,7 @@ pub async fn app(config: Config, host: String, port: u16) -> Router {
         context: Context::new(config.clone()).await,
     };
 
-    let api_state = ApiServiceState {
-        context: Context::new(config).await,
-    };
-
-    // add RequestDecompressionLayer for handle gzip encode
-    // add TraceLayer for log record
-    // add CorsLayer to add cors header
     Router::new()
-        .nest("/api/", api_router::routers().with_state(api_state))
         .route(
             "/*path",
             get(get_method_router)
@@ -93,11 +82,10 @@ async fn get_method_router(
 }
 
 async fn post_method_router(
-    state: State<AppState>,
+    _state: State<AppState>,
     uri: Uri,
     req: Request<Body>,
 ) -> Result<Response<Body>, (StatusCode, String)> {
-    let _ztm_config = state.context.config.ztm.clone();
     if Regex::new(r"/certificates/[a-zA-Z0-9]+$")
         .unwrap()
         .is_match(uri.path())

aries/src/service/mod.rs

@@ -0,0 +1,5 @@
+pub mod ca_server;
+pub mod relay_server;
+
+#[cfg(test)]
+mod tests {}