web3infra-foundation · genedna · May 31, 2024 · May 31, 2024 · May 31, 2024
diff --git a/common/src/config.rs b/common/src/config.rs
@@ -11,7 +11,7 @@ pub struct Config {
     pub storage: StorageConfig,
     pub monorepo: MonoConfig,
     pub pack: PackConfig,
-    pub relay: RelayConfig,
+    pub ztm: ZTMConfig,
 }
 
 impl Config {
@@ -137,16 +137,18 @@ impl Default for PackConfig {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct RelayConfig {
+pub struct ZTMConfig {
     pub ca: String,
     pub hub: String,
+    pub agent: String,
 }
 
-impl Default for RelayConfig {
+impl Default for ZTMConfig {
     fn default() -> Self {
         Self {
             ca: String::from("127.0.0.1:9999"),
             hub: String::from("127.0.0.1:8888"),
+            agent: String::from("127.0.0.1:7777"),
         }
     }
 }
diff --git a/gateway/src/relay_server.rs b/gateway/src/relay_server.rs
@@ -3,7 +3,7 @@ use std::str::FromStr;
 
 use axum::body::Body;
 use axum::extract::{Query, State};
-use axum::http::{Response, StatusCode, Uri};
+use axum::http::{Request, Response, StatusCode, Uri};
 use axum::routing::get;
 use axum::Router;
 use clap::Args;
@@ -74,8 +74,8 @@ pub async fn app(config: Config, host: String, port: u16) -> Router {
         )
         .route(
             "/*path",
-            get(get_method_router), // .post(post_method_router)
-                                    // .put(put_method_router),
+            get(get_method_router).post(post_method_router),
+            // .put(put_method_router),
         )
         .layer(ServiceBuilder::new().layer(CorsLayer::new().allow_origin(Any)))
         .layer(TraceLayer::new_for_http())
@@ -88,11 +88,26 @@ async fn get_method_router(
     Query(params): Query<RelayGetParams>,
     uri: Uri,
 ) -> Result<Response<Body>, (StatusCode, String)> {
-    let relay_config = state.context.config.relay.clone();
+    let ztm_config = state.context.config.ztm.clone();
     if Regex::new(r"/hello$").unwrap().is_match(uri.path()) {
         return gemini::http::handler::hello_gemini(params).await;
     } else if Regex::new(r"/certificate$").unwrap().is_match(uri.path()) {
-        return gemini::ztm::handler::get_ztm_certificate(relay_config, params).await;
+        return gemini::http::handler::certificate(ztm_config, params).await;
+    }
+    Err((
+        StatusCode::NOT_FOUND,
+        String::from("Operation not supported\n"),
+    ))
+}
+
+async fn post_method_router(
+    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"/relay_init$").unwrap().is_match(uri.path()) {
+        return gemini::http::handler::init(ztm_config, req, state.0.port).await;
     }
     Err((
         StatusCode::NOT_FOUND,

diff --git a/gemini/src/http/handler.rs b/gemini/src/http/handler.rs
@@ -1,15 +1,88 @@
 use axum::{
-    body::Body,
-    http::{Response, StatusCode},
+    body::{to_bytes, Body},
+    http::{Request, Response, StatusCode},
 };
+use common::config::ZTMConfig;
 
-use crate::RelayGetParams;
+use crate::{
+    ztm::{
+        ZTMUserPermit, {connect_ztm_hub, create_ztm_certificate, create_ztm_service},
+    },
+    RelayGetParams,
+};
 
 pub async fn hello_gemini(_params: RelayGetParams) -> Result<Response<Body>, (StatusCode, String)> {
     Ok(Response::builder()
         .body(Body::from("hello gemini"))
         .unwrap())
 }
 
+pub async fn certificate(
+    config: ZTMConfig,
+    params: RelayGetParams,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    if params.name.is_none() {
+        return Err((StatusCode::BAD_REQUEST, "not enough paras".to_string()));
+    }
+    let name = params.name.unwrap();
+    let permit = match create_ztm_certificate(config, name.clone()).await {
+        Ok(p) => p,
+        Err(e) => {
+            return Err((StatusCode::INTERNAL_SERVER_ERROR, e));
+        }
+    };
+
+    let permit_json = serde_json::to_string(&permit).unwrap();
+    tracing::info!("new permit [{name}]: {permit_json}");
+
+    Ok(Response::builder()
+        .header("Content-Type", "application/json")
+        .body(Body::from(permit_json))
+        .unwrap())
+}
+
+pub async fn init(
+    config: ZTMConfig,
+    req: Request<Body>,
+    relay_port: u16,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    // transfer body to json
+    let body_bytes = match to_bytes(req.into_body(), usize::MAX).await {
+        Ok(b) => b,
+        Err(e) => {
+            return Err((StatusCode::BAD_REQUEST, e.to_string()));
+        }
+    };
+
+    let permit: ZTMUserPermit = match serde_json::from_slice(&body_bytes) {
+        Ok(p) => p,
+        Err(e) => {
+            return Err((StatusCode::BAD_REQUEST, e.to_string()));
+        }
+    };
+
+    // 1. connect to ZTM hub (join a mesh)
+    let mesh = match connect_ztm_hub(config.clone(), permit).await {
+        Ok(m) => m,
+        Err(e) => {
+            return Err((StatusCode::INTERNAL_SERVER_ERROR, e));
+        }
+    };
+
+    // 2. create a ZTM service
+    let response_text =
+        match create_ztm_service(config, mesh.agent.id, "relay".to_string(), relay_port).await {
+            Ok(m) => m,
+            Err(e) => {
+                return Err((StatusCode::INTERNAL_SERVER_ERROR, e));
+            }
+        };
+
+    Ok(Response::builder()
+        .header("Content-Type", "application/json")
+        .body(Body::from(response_text))
+        .unwrap())
+}
+
 #[cfg(test)]
 mod tests {}
diff --git a/gemini/src/ztm/handler.rs b/gemini/src/ztm/handler.rs