fix

crates/notify/examples/full_demo.rs

@@ -1,8 +1,6 @@
-use notify::arn::TargetID;
-use notify::global::notification_system;
-use notify::{
-    init_logger, BucketNotificationConfig, Event, EventName, LogLevel, NotificationError,
-};
+use rustfs_notify::arn::TargetID;
+use rustfs_notify::global::notification_system;
+use rustfs_notify::{init_logger, BucketNotificationConfig, Event, EventName, LogLevel, NotificationError};
 use std::time::Duration;
 use tracing::info;
 
@@ -12,18 +10,24 @@ async fn main() -> Result<(), NotificationError> {
 
     let system = notification_system();
 
-    // --- 初始配置 (Webhook 和 MQTT) ---
-    let mut config = notify::Config::new();
-
+    // --- Initial configuration (Webhook and MQTT) ---
+    let mut config = rustfs_notify::Config::new();
+    let current_root = rustfs_utils::dirs::get_project_root().expect("failed to get project root");
+    println!("Current project root: {}", current_root.display());
     // Webhook target configuration
-    let mut webhook_kvs = notify::KVS::new();
+    let mut webhook_kvs = rustfs_notify::KVS::new();
     webhook_kvs.set("enable", "on");
     webhook_kvs.set("endpoint", "http://127.0.0.1:3020/webhook");
     webhook_kvs.set("auth_token", "secret-token");
     // webhook_kvs.set("queue_dir", "/tmp/data/webhook");
     webhook_kvs.set(
         "queue_dir",
-        "/Users/qun/Documents/rust/rustfs/notify/logs/webhook",
+        current_root
+            .clone()
+            .join("../../deploy/logs/notify/webhook")
+            .to_str()
+            .unwrap()
+            .to_string(),
     );
     webhook_kvs.set("queue_limit", "10000");
     let mut webhook_targets = std::collections::HashMap::new();
@@ -31,7 +35,7 @@ async fn main() -> Result<(), NotificationError> {
     config.insert("notify_webhook".to_string(), webhook_targets);
 
     // MQTT target configuration
-    let mut mqtt_kvs = notify::KVS::new();
+    let mut mqtt_kvs = rustfs_notify::KVS::new();
     mqtt_kvs.set("enable", "on");
     mqtt_kvs.set("broker", "mqtt://localhost:1883");
     mqtt_kvs.set("topic", "rustfs/events");
@@ -41,7 +45,11 @@ async fn main() -> Result<(), NotificationError> {
     // webhook_kvs.set("queue_dir", "/tmp/data/mqtt");
     mqtt_kvs.set(
         "queue_dir",
-        "/Users/qun/Documents/rust/rustfs/notify/logs/mqtt",
+        current_root
+            .join("../../deploy/logs/notify/mqtt")
+            .to_str()
+            .unwrap()
+            .to_string(),
     );
     mqtt_kvs.set("queue_limit", "10000");
 
@@ -49,35 +57,32 @@ async fn main() -> Result<(), NotificationError> {
     mqtt_targets.insert("1".to_string(), mqtt_kvs);
     config.insert("notify_mqtt".to_string(), mqtt_targets);
 
-    // 加载配置并初始化系统
+    // Load the configuration and initialize the system
     *system.config.write().await = config;
     system.init().await?;
     info!("✅ System initialized with Webhook and MQTT targets.");
 
-    // --- 1. 查询当前活动的 Target ---
+    // --- Query the currently active Target ---
     let active_targets = system.get_active_targets().await;
     info!("\n---> Currently active targets: {:?}", active_targets);
     assert_eq!(active_targets.len(), 2);
 
     tokio::time::sleep(Duration::from_secs(1)).await;
 
-    // --- 2. 精确删除一个 Target (例如 MQTT) ---
+    // --- Exactly delete a Target (e.g. MQTT) ---
     info!("\n---> Removing MQTT target...");
     let mqtt_target_id = TargetID::new("1".to_string(), "mqtt".to_string());
     system.remove_target(&mqtt_target_id, "notify_mqtt").await?;
     info!("✅ MQTT target removed.");
 
-    // --- 3. 再次查询活动的 Target ---
+    // --- Query the activity's Target again ---
     let active_targets_after_removal = system.get_active_targets().await;
-    info!(
-        "\n---> Active targets after removal: {:?}",
-        active_targets_after_removal
-    );
+    info!("\n---> Active targets after removal: {:?}", active_targets_after_removal);
     assert_eq!(active_targets_after_removal.len(), 1);
     assert_eq!(active_targets_after_removal[0].id, "1".to_string());
 
-    // --- 4. 发送事件进行验证 ---
-    // 配置一个规则，指向 Webhook 和已删除的 MQTT
+    // --- Send events for verification ---
+    // Configure a rule to point to the Webhook and deleted MQTT
     let mut bucket_config = BucketNotificationConfig::new("us-east-1");
     bucket_config.add_rule(
         &[EventName::ObjectCreatedPut],
@@ -87,20 +92,16 @@ async fn main() -> Result<(), NotificationError> {
     bucket_config.add_rule(
         &[EventName::ObjectCreatedPut],
         "*".to_string(),
-        TargetID::new("1".to_string(), "mqtt".to_string()), // 这个规则会匹配，但找不到 Target
+        TargetID::new("1".to_string(), "mqtt".to_string()), // This rule will match, but the Target cannot be found
     );
-    system
-        .load_bucket_notification_config("my-bucket", &bucket_config)
-        .await?;
+    system.load_bucket_notification_config("my-bucket", &bucket_config).await?;
 
     info!("\n---> Sending an event...");
     let event = Event::new_test_event("my-bucket", "document.pdf", EventName::ObjectCreatedPut);
     system
         .send_event("my-bucket", "s3:ObjectCreated:Put", "document.pdf", event)
         .await;
-    info!(
-        "✅ Event sent. Only the Webhook target should receive it. Check logs for warnings about the missing MQTT target."
-    );
+    info!("✅ Event sent. Only the Webhook target should receive it. Check logs for warnings about the missing MQTT target.");
 
     tokio::time::sleep(Duration::from_secs(2)).await;
 

crates/notify/examples/full_demo_one.rs

@@ -1,9 +1,8 @@
-use notify::arn::TargetID;
-use notify::global::notification_system;
-// 1. 使用全局访问器
-use notify::{
-    init_logger, BucketNotificationConfig, Event, EventName, LogLevel, NotificationError, KVS,
-};
+// Using Global Accessories
+use rustfs_config::notify;
+use rustfs_notify::arn::TargetID;
+use rustfs_notify::global::notification_system;
+use rustfs_notify::{init_logger, BucketNotificationConfig, Event, EventName, LogLevel, NotificationError, KVS};
 use std::time::Duration;
 use tracing::info;
 
@@ -11,11 +10,12 @@ use tracing::info;
 async fn main() -> Result<(), NotificationError> {
     init_logger(LogLevel::Debug);
 
-    // 获取全局 NotificationSystem 实例
+    // Get global NotificationSystem instance
     let system = notification_system();
 
-    // --- 初始配置 ---
-    let mut config = notify::Config::new();
+    // --- Initial configuration ---
+    let mut config = rustfs_notify::Config::new();
+    let current_root = rustfs_utils::dirs::get_project_root().expect("failed to get project root");
     // Webhook target
     let mut webhook_kvs = KVS::new();
     webhook_kvs.set("enable", "on");
@@ -23,20 +23,25 @@ async fn main() -> Result<(), NotificationError> {
     // webhook_kvs.set("queue_dir", "./logs/webhook");
     webhook_kvs.set(
         "queue_dir",
-        "/Users/qun/Documents/rust/rustfs/notify/logs/webhook",
+        current_root
+            .clone()
+            .join("/deploy/logs/notify/webhook")
+            .to_str()
+            .unwrap()
+            .to_string(),
     );
     let mut webhook_targets = std::collections::HashMap::new();
     webhook_targets.insert("1".to_string(), webhook_kvs);
     config.insert("notify_webhook".to_string(), webhook_targets);
 
-    // 加载初始配置并初始化系统
+    // Load the initial configuration and initialize the system
     *system.config.write().await = config;
     system.init().await?;
     info!("✅ System initialized with Webhook target.");
 
     tokio::time::sleep(Duration::from_secs(1)).await;
 
-    // --- 2. 动态更新系统配置：添加一个 MQTT Target ---
+    // --- Dynamically update system configuration: Add an MQTT Target ---
     info!("\n---> Dynamically adding MQTT target...");
     let mut mqtt_kvs = KVS::new();
     mqtt_kvs.set("enable", "on");
@@ -47,18 +52,13 @@ async fn main() -> Result<(), NotificationError> {
     mqtt_kvs.set("password", "123456");
     mqtt_kvs.set("queue_limit", "10000");
     // mqtt_kvs.set("queue_dir", "./logs/mqtt");
-    mqtt_kvs.set(
-        "queue_dir",
-        "/Users/qun/Documents/rust/rustfs/notify/logs/mqtt",
-    );
-    system
-        .set_target_config("notify_mqtt", "1", mqtt_kvs)
-        .await?;
+    mqtt_kvs.set("queue_dir", current_root.join("/deploy/logs/notify/mqtt").to_str().unwrap().to_string());
+    system.set_target_config("notify_mqtt", "1", mqtt_kvs).await?;
     info!("✅ MQTT target added and system reloaded.");
 
     tokio::time::sleep(Duration::from_secs(1)).await;
 
-    // --- 3. 加载和管理 Bucket 配置 ---
+    // --- Loading and managing Bucket configurations ---
     info!("\n---> Loading bucket notification config...");
     let mut bucket_config = BucketNotificationConfig::new("us-east-1");
     bucket_config.add_rule(
@@ -71,12 +71,10 @@ async fn main() -> Result<(), NotificationError> {
         "*".to_string(),
         TargetID::new("1".to_string(), "mqtt".to_string()),
     );
-    system
-        .load_bucket_notification_config("my-bucket", &bucket_config)
-        .await?;
+    system.load_bucket_notification_config("my-bucket", &bucket_config).await?;
     info!("✅ Bucket 'my-bucket' config loaded.");
 
-    // --- 发送事件 ---
+    // --- Send events ---
     info!("\n---> Sending an event...");
     let event = Event::new_test_event("my-bucket", "document.pdf", EventName::ObjectCreatedPut);
     system
@@ -86,7 +84,7 @@ async fn main() -> Result<(), NotificationError> {
 
     tokio::time::sleep(Duration::from_secs(2)).await;
 
-    // --- 动态移除配置 ---
+    // --- Dynamically remove configuration ---
     info!("\n---> Dynamically removing Webhook target...");
     system.remove_target_config("notify_webhook", "1").await?;
     info!("✅ Webhook target removed and system reloaded.");

crates/notify/examples/webhook.rs

@@ -16,40 +16,37 @@ struct ResetParams {
     reason: Option<String>,
 }
 
-// 定义一个全局变量 统计接受到数据条数
+// Define a global variable and count the number of data received
 use std::sync::atomic::{AtomicU64, Ordering};
 
 static WEBHOOK_COUNT: AtomicU64 = AtomicU64::new(0);
 
 #[tokio::main]
 async fn main() {
-    // 构建应用
+    // Build an application
     let app = Router::new()
         .route("/webhook", post(receive_webhook))
-        .route(
-            "/webhook/reset/{reason}",
-            get(reset_webhook_count_with_path),
-        )
+        .route("/webhook/reset/{reason}", get(reset_webhook_count_with_path))
         .route("/webhook/reset", get(reset_webhook_count))
         .route("/webhook", get(receive_webhook));
-    // 启动服务器
+    // Start the server
     let addr = "0.0.0.0:3020";
     let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
     println!("Server running on {}", addr);
 
-    // 服务启动后进行自检
+    // Self-checking after the service is started
     tokio::spawn(async move {
-        // 给服务器一点时间启动
+        // Give the server some time to start
         tokio::time::sleep(std::time::Duration::from_secs(1)).await;
 
         match is_service_active(addr).await {
-            Ok(true) => println!("服务健康检查：成功 - 服务正常运行"),
-            Ok(false) => eprintln!("服务健康检查：失败 - 服务未响应"),
-            Err(e) => eprintln!("服务健康检查错误：{}", e),
+            Ok(true) => println!("Service health check: Successful - Service is running normally"),
+            Ok(false) => eprintln!("Service Health Check: Failed - Service Not Responded"),
+            Err(e) => eprintln!("Service health check errors:{}", e),
         }
     });
 
-    // 创建关闭信号处理
+    // Create a shutdown signal processing
     tokio::select! {
         result = axum::serve(listener, app) => {
             if let Err(e) = result {
@@ -62,16 +59,14 @@ async fn main() {
     }
 }
 
-/// 创建一个方法重置 WEBHOOK_COUNT 的值
-async fn reset_webhook_count_with_path(
-    axum::extract::Path(reason): axum::extract::Path<String>,
-) -> Response<String> {
-    // 输出当前计数器的值
+/// Create a method to reset the value of WEBHOOK_COUNT
+async fn reset_webhook_count_with_path(axum::extract::Path(reason): axum::extract::Path<String>) -> Response<String> {
+    // Output the value of the current counter
     let current_count = WEBHOOK_COUNT.load(Ordering::SeqCst);
     println!("Current webhook count: {}", current_count);
 
     println!("Reset webhook count, reason: {}", reason);
-    // 将计数器重置为 0
+    // Reset the counter to 0
     WEBHOOK_COUNT.store(0, Ordering::SeqCst);
     println!("Webhook count has been reset to 0.");
 
@@ -85,17 +80,14 @@ async fn reset_webhook_count_with_path(
         .unwrap()
 }
 
-/// 创建一个方法重置 WEBHOOK_COUNT 的值
-/// 可以通过调用此方法来重置计数器
-async fn reset_webhook_count(
-    Query(params): Query<ResetParams>,
-    headers: HeaderMap,
-) -> Response<String> {
-    // 输出当前计数器的值
+/// Create a method to reset the value of WEBHOOK_COUNT
+/// You can reset the counter by calling this method
+async fn reset_webhook_count(Query(params): Query<ResetParams>, headers: HeaderMap) -> Response<String> {
+    // Output the value of the current counter
     let current_count = WEBHOOK_COUNT.load(Ordering::SeqCst);
     println!("Current webhook count: {}", current_count);
 
-    let reason = params.reason.unwrap_or_else(|| "未提供原因".to_string());
+    let reason = params.reason.unwrap_or_else(|| "Reason not provided".to_string());
     println!("Reset webhook count, reason: {}", reason);
 
     for header in headers {
@@ -104,51 +96,41 @@ async fn reset_webhook_count(
     }
 
     println!("Reset webhook count printed headers");
-    // 将计数器重置为 0
+    // Reset the counter to 0
     WEBHOOK_COUNT.store(0, Ordering::SeqCst);
     println!("Webhook count has been reset to 0.");
     Response::builder()
         .header("Foo", "Bar")
         .status(StatusCode::OK)
-        .body(format!(
-            "Webhook count reset successfully current_count:{}",
-            current_count
-        ))
+        .body(format!("Webhook count reset successfully current_count:{}", current_count))
         .unwrap()
 }
 
 async fn is_service_active(addr: &str) -> Result<bool, String> {
     let socket_addr = tokio::net::lookup_host(addr)
         .await
-        .map_err(|e| format!("无法解析主机：{}", e))?
+        .map_err(|e| format!("Unable to resolve host:{}", e))?
         .next()
-        .ok_or_else(|| "未找到地址".to_string())?;
+        .ok_or_else(|| "Address not found".to_string())?;
 
-    println!("正在检查服务状态：{}", socket_addr);
+    println!("Checking service status:{}", socket_addr);
 
-    match tokio::time::timeout(
-        std::time::Duration::from_secs(5),
-        tokio::net::TcpStream::connect(socket_addr),
-    )
-    .await
-    {
+    match tokio::time::timeout(std::time::Duration::from_secs(5), tokio::net::TcpStream::connect(socket_addr)).await {
         Ok(Ok(_)) => Ok(true),
         Ok(Err(e)) => {
             if e.kind() == std::io::ErrorKind::ConnectionRefused {
                 Ok(false)
             } else {
-                Err(format!("连接失败：{}", e))
+                Err(format!("Connection failed:{}", e))
             }
         }
-        Err(_) => Err("连接超时".to_string()),
+        Err(_) => Err("Connection timeout".to_string()),
     }
 }
 
 async fn receive_webhook(Json(payload): Json<Value>) -> StatusCode {
     let start = SystemTime::now();
-    let since_the_epoch = start
-        .duration_since(UNIX_EPOCH)
-        .expect("Time went backwards");
+    let since_the_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards");
 
     // get the number of seconds since the unix era
     let seconds = since_the_epoch.as_secs();
@@ -157,20 +139,14 @@ async fn receive_webhook(Json(payload): Json<Value>) -> StatusCode {
     let (year, month, day, hour, minute, second) = convert_seconds_to_date(seconds);
 
     // output result
-    println!(
-        "current time:{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
-        year, month, day, hour, minute, second
-    );
+    println!("current time:{:04}-{:02}-{:02} {:02}:{:02}:{:02}", year, month, day, hour, minute, second);
     println!(
         "received a webhook request time:{} content:\n {}",
         seconds,
         serde_json::to_string_pretty(&payload).unwrap()
     );
     WEBHOOK_COUNT.fetch_add(1, Ordering::SeqCst);
-    println!(
-        "Total webhook requests received: {}",
-        WEBHOOK_COUNT.load(Ordering::SeqCst)
-    );
+    println!("Total webhook requests received: {}", WEBHOOK_COUNT.load(Ordering::SeqCst));
     StatusCode::OK
 }
 
@@ -221,12 +197,5 @@ fn convert_seconds_to_date(seconds: u64) -> (u32, u32, u32, u32, u32, u32) {
     // calculate the number of seconds
     second += total_seconds;
 
-    (
-        year as u32,
-        month as u32,
-        day as u32,
-        hour as u32,
-        minute as u32,
-        second as u32,
-    )
+    (year as u32, month as u32, day as u32, hour as u32, minute as u32, second as u32)
 }