Update tardis to 0.1.0 rc.1 (ideal-world#25)

* prepare update for tardis beta 13

* update

* cargo fmt

Author: 4t145

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 members = ["kernel", "services/*"]
-resolver="2"
+resolver = "2"
 
 [profile.release]
 lto = true
@@ -33,9 +33,9 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 urlencoding = { version = "2" }
 
 # Tardis
-tardis = { version = "0.1.0-beta.12" }
+tardis = { version = "0.1.0-rc.1" }
 # tardis = { path = "../tardis/tardis" }
-#tardis = { git = "https://github.com/ideal-world/tardis.git", rev = "9424e16" }
+# tardis = { git = "https://github.com/ideal-world/tardis.git", rev = "25baf2a" }
 
 # Http
 http = { version = "0.2" }
@@ -54,7 +54,7 @@ schemars = { version = "0.8.6" }
 
 # Test
 reqwest = { version = "0.11", features = ["json", "gzip", "brotli"] }
-
+testcontainers-modules = { version = "0.1" }
 #async-compression 
 async-compression = { version = "0.3.13", default-features = false, features = [
   "tokio",

kernel/Cargo.toml

@@ -53,7 +53,7 @@ tardis = { workspace = true, features = ["test", "web-client", "web-server"] }
 reqwest = { workspace = true }
 tracing-subscriber = { workspace = true }
 criterion = { version = "0.5", features = ["async_tokio"] }
-
+testcontainers-modules ={ workspace = true }
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

kernel/src/config/config_by_k8s.rs

@@ -341,7 +341,7 @@ pub async fn init(namespaces: Option<String>) -> TardisResult<Vec<(SgGateway, Ve
 }
 
 async fn get_http_spaceroute_by_api(
-    gateway_uniques: &Vec<String>,
+    gateway_uniques: &[String],
     (http_spaceroute_api, http_route_api): (&Api<HttpSpaceroute>, &Api<HttpRoute>),
 ) -> TardisResult<Vec<HttpSpaceroute>> {
     let mut http_route_objs: Vec<HttpSpaceroute> = http_spaceroute_api
@@ -431,7 +431,7 @@ async fn overload_gateway(gateway_obj: Gateway, http_route_api_refs: (&Api<HttpS
                     let mut gateway_uniques_guard = GATEWAY_UNIQUES.write().await;
                     gateway_uniques_guard.push(gateway_config.name.clone());
                 }
-                let http_route_objs: Vec<HttpSpaceroute> = get_http_spaceroute_by_api(&vec![gateway_unique], http_route_api_refs)
+                let http_route_objs: Vec<HttpSpaceroute> = get_http_spaceroute_by_api(&[gateway_unique], http_route_api_refs)
                     .await
                     .map_err(|error| TardisError::wrap(&format!("[SG.Config] Get HttpRoute Kubernetes error: {error:?}"), ""))
                     .expect("");
@@ -515,7 +515,7 @@ async fn overload_http_route(gateway_obj: Gateway, http_route_api_refs: (&Api<Ht
         .expect("[SG.Config] Gateway config not found for http_route parent ref")
         .clone();
 
-    let http_route_objs: Vec<HttpSpaceroute> = get_http_spaceroute_by_api(&vec![gateway_unique], http_route_api_refs)
+    let http_route_objs: Vec<HttpSpaceroute> = get_http_spaceroute_by_api(&[gateway_unique], http_route_api_refs)
         .await
         .map_err(|error| TardisError::wrap(&format!("[SG.Config] Get HttpRoute Kubernetes error: {error:?}"), ""))
         .expect("");

kernel/src/functions/cache_client.rs

@@ -6,6 +6,7 @@ use std::{
 use tardis::{
     basic::{error::TardisError, result::TardisResult},
     cache::cache_client::TardisCacheClient,
+    config::config_dto::CacheModuleConfig,
     tokio::sync::RwLock,
 };
 
@@ -15,7 +16,7 @@ pub fn cache_clients() -> &'static RwLock<HashMap<String, Arc<TardisCacheClient>
 }
 
 pub async fn init(name: impl Into<String>, url: &str) -> TardisResult<()> {
-    let cache = TardisCacheClient::init(url).await?;
+    let cache = TardisCacheClient::init(&CacheModuleConfig::builder().url(url.parse().expect("invalid url")).build()).await?;
     {
         let mut write = cache_clients().write().await;
         write.insert(name.into(), Arc::new(cache));

kernel/src/functions/server.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use std::vec::Vec;
 use std::{io, sync};
-use tardis::basic::tracing::TardisTracing;
+use tardis::config::config_dto::LogConfig;
 use tardis::tokio::time::timeout;
 use tardis::{
     basic::{error::TardisError, result::TardisResult},
@@ -52,7 +52,19 @@ pub async fn init(gateway_conf: &SgGateway) -> TardisResult<Vec<SgServerInst>> {
     }
     if let Some(log_level) = gateway_conf.parameters.log_level.clone() {
         log::debug!("[SG.Server] change log level to {log_level}");
-        TardisTracing::update_log_level_by_domain_code(crate::constants::DOMAIN_CODE, &log_level)?;
+        let fw_config = TardisFuns::fw_config();
+        let old_configs = fw_config.log();
+        let directive = format!("{domain}={log_level}", domain = crate::constants::DOMAIN_CODE).parse().expect("invalid directive");
+        let mut directives = old_configs.directives.clone();
+        if let Some(index) = directives.iter().position(|d| d.to_string().starts_with(crate::constants::DOMAIN_CODE)) {
+            directives.remove(index);
+        }
+        directives.push(directive);
+        TardisFuns::tracing().update_config(&LogConfig {
+            level: old_configs.level.clone(),
+            directives,
+            ..Default::default()
+        })?;
     }
     let (shutdown_tx, _) = tokio::sync::watch::channel(());
 

kernel/src/functions/websocket.rs

@@ -141,10 +141,7 @@ pub async fn process(gateway_name: Arc<String>, remote_addr: SocketAddr, backend
             }
         }
     });
-    let accept_key = TardisFuns::crypto.base64.encode_raw(TardisFuns::crypto.digest.digest_raw(
-        format!("{request_key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11").as_bytes(),
-        tardis::crypto::rust_crypto::sha1::Sha1::new(),
-    )?);
+    let accept_key = TardisFuns::crypto.base64.encode_raw(TardisFuns::crypto.digest.sha1(format!("{request_key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11").as_bytes())?);
 
     let mut response = Response::new(Body::empty());
     *response.status_mut() = StatusCode::SWITCHING_PROTOCOLS;

kernel/src/helpers/k8s_helper.rs

@@ -21,6 +21,6 @@ pub(crate) fn get_k8s_obj_unique(obj: &impl kube::Resource) -> String {
 }
 
 /// Get uid and version map
-pub(crate) fn get_obj_uid_version_map(resources: &Vec<impl kube::Resource>) -> HashMap<String, String> {
+pub(crate) fn get_obj_uid_version_map(resources: &[impl kube::Resource]) -> HashMap<String, String> {
     resources.iter().map(|res| (res.meta().uid.clone().unwrap_or("".to_string()), res.meta().resource_version.clone().unwrap_or_default())).collect()
 }

kernel/src/plugins/filters/status.rs

@@ -276,13 +276,13 @@ mod tests {
 
     use http::{HeaderMap, Method, StatusCode, Uri, Version};
     use hyper::Body;
-
     use tardis::{
         basic::{error::TardisError, result::TardisResult},
         test::test_container::TardisTestContainer,
-        testcontainers::{self, clients::Cli, images::redis::Redis, Container},
+        testcontainers::{self, clients::Cli, Container},
         tokio,
     };
+    use testcontainers_modules::redis::Redis;
 
     #[cfg(feature = "cache")]
     use crate::functions;

kernel/tests/init_cache_container.rs

@@ -1,8 +1,8 @@
 use tardis::basic::result::TardisResult;
 use tardis::test::test_container::TardisTestContainer;
 use tardis::testcontainers::clients::Cli;
-use tardis::testcontainers::images::redis::Redis;
 use tardis::testcontainers::Container;
+use testcontainers_modules::redis::Redis;
 
 pub struct LifeHold<'a> {
     pub redis: Container<'a, Redis>,

kernel/tests/test_config_by_redis.rs

@@ -5,6 +5,7 @@ use serde_json::Value;
 use tardis::{
     basic::result::TardisResult,
     cache::cache_client::TardisCacheClient,
+    config::config_dto::{CacheModuleConfig, WebClientModuleConfig},
     testcontainers,
     tokio::{self, time::sleep},
     web::web_client::TardisWebClient,
@@ -14,14 +15,19 @@ use tardis::{
 async fn test_config_by_redis() -> TardisResult<()> {
     env::set_var("RUST_LOG", "info,spacegate_kernel=trace");
     tracing_subscriber::fmt::init();
-    let http_client = TardisWebClient::init(100)?;
+    let http_client = TardisWebClient::init(&WebClientModuleConfig {
+        connect_timeout_sec: 100,
+        ..Default::default()
+    })?;
     let docker = testcontainers::clients::Cli::default();
     let (cache_url, _x) = init_cache_container::init(&docker).await?;
-
     // Without keys
     assert!(spacegate_kernel::startup(false, Some(cache_url.clone()), None).await.is_err());
 
-    let cache_client = TardisCacheClient::init(&cache_url).await?;
+    let cache_client = TardisCacheClient::init(&CacheModuleConfig {
+        url: cache_url.parse().expect("invalid url"),
+    })
+    .await?;
     cache_client
         .hset(
             "sg:conf:gateway",

kernel/tests/test_custom_plugin.rs

@@ -15,6 +15,7 @@ use spacegate_kernel::{
     def_filter,
     plugins::filters::SgPluginFilter,
 };
+use tardis::config::config_dto::WebClientModuleConfig;
 use tardis::{
     basic::{error::TardisError, result::TardisResult},
     tokio::{self, time::sleep},
@@ -79,11 +80,14 @@ async fn test_custom_plugin() -> TardisResult<()> {
     )
     .await?;
     sleep(Duration::from_millis(500)).await;
-    let client = TardisWebClient::init(100)?;
+    let client = TardisWebClient::init(&WebClientModuleConfig {
+        connect_timeout_sec: 100,
+        ..Default::default()
+    })?;
     let resp = client.get_to_str("http://localhost:8888/get?dd", None).await?;
     assert_eq!(resp.code, 401);
 
-    let resp = client.get::<Value>("http://localhost:8888/get?dd", Some(vec![("Authorization".to_string(), "xxxxx".to_string())])).await?;
+    let resp = client.get::<Value>("http://localhost:8888/get?dd", [("Authorization".to_string(), "xxxxx".to_string())]).await?;
     assert_eq!(resp.code, 200);
     assert!(resp.body.unwrap().get("url").unwrap().as_str().unwrap().contains("https://localhost/get?dd"));
     Ok(())

kernel/tests/test_https.rs

@@ -7,6 +7,7 @@ use spacegate_kernel::config::{
 };
 use tardis::{
     basic::result::TardisResult,
+    config::config_dto::WebClientModuleConfig,
     tokio::{self, time::sleep},
     web::web_client::{TardisHttpResponse, TardisWebClient},
 };
@@ -152,7 +153,10 @@ async fn test_https() -> TardisResult<()> {
     )
     .await?;
     sleep(Duration::from_millis(500)).await;
-    let client = TardisWebClient::init(100)?;
+    let client = TardisWebClient::init(&WebClientModuleConfig {
+        connect_timeout_sec: 100,
+        ..Default::default()
+    })?;
     let resp: TardisHttpResponse<Value> = client
         .post(
             "https://localhost:8888/post?dd",
@@ -165,7 +169,10 @@ async fn test_https() -> TardisResult<()> {
         .await?;
     assert!(resp.body.unwrap().get("data").unwrap().to_string().contains("星航"));
 
-    let client = TardisWebClient::init(100)?;
+    let client = TardisWebClient::init(&WebClientModuleConfig {
+        connect_timeout_sec: 100,
+        ..Default::default()
+    })?;
     let resp: TardisHttpResponse<Value> = client
         .post(
             "https://localhost:8889/post?dd",
@@ -178,7 +185,10 @@ async fn test_https() -> TardisResult<()> {
         .await?;
     assert!(resp.body.unwrap().get("data").unwrap().to_string().contains("星航"));
 
-    let client = TardisWebClient::init(100)?;
+    let client = TardisWebClient::init(&WebClientModuleConfig {
+        connect_timeout_sec: 100,
+        ..Default::default()
+    })?;
     let resp: TardisHttpResponse<Value> = client
         .post(
             "https://localhost:8890/post?dd",

kernel/tests/test_websocket.rs

@@ -19,11 +19,12 @@ use spacegate_kernel::config::{
     plugin_filter_dto,
 };
 use spacegate_kernel::plugins::filters;
+use tardis::config::config_dto::WebServerCommonConfig;
 use tardis::web::web_server::WebServerModule;
 use tardis::web::ws_processor::TardisWebsocketMgrMessage;
 use tardis::{
     basic::result::TardisResult,
-    config::config_dto::{CacheConfig, DBConfig, FrameworkConfig, MQConfig, MailConfig, OSConfig, SearchConfig, TardisConfig, WebServerConfig},
+    config::config_dto::{FrameworkConfig, TardisConfig, WebServerConfig},
     tokio::{
         self,
         sync::{broadcast::Sender, RwLock},
@@ -51,36 +52,7 @@ async fn test_webscoket() -> TardisResult<()> {
         cs: Default::default(),
         fw: FrameworkConfig {
             app: Default::default(),
-            web_server: WebServerConfig {
-                enabled: true,
-                port: 8081,
-                ..Default::default()
-            },
-            web_client: Default::default(),
-            cache: CacheConfig {
-                enabled: false,
-                ..Default::default()
-            },
-            db: DBConfig {
-                enabled: false,
-                ..Default::default()
-            },
-            mq: MQConfig {
-                enabled: false,
-                ..Default::default()
-            },
-            search: SearchConfig {
-                enabled: false,
-                ..Default::default()
-            },
-            mail: MailConfig {
-                enabled: false,
-                ..Default::default()
-            },
-            os: OSConfig {
-                enabled: false,
-                ..Default::default()
-            },
+            web_server: Some(WebServerConfig::builder().common(WebServerCommonConfig::builder().port(8081).build()).default(Default::default()).build()),
             ..Default::default()
         },
     })