feat: rename crate from rustfs-event-notifier to rustfs-event

This change simplifies the crate name to better reflect its core functionality
as the event handling system for RustFS. The renamed package maintains all
existing functionality while improving naming consistency across the project.

- Updated all imports and references to use the new crate name
- Maintained API compatibility with existing implementations
- Updated tests to reflect the name change

crates/event/examples/.env.example

@@ -0,0 +1,28 @@
+## ===== global configuration =====
+#NOTIFIER__STORE_PATH=/var/log/event-notification
+#NOTIFIER__CHANNEL_CAPACITY=5000
+#
+## ===== adapter configuration array format =====
+## webhook adapter index 0
+#NOTIFIER__ADAPTERS_0__type=Webhook
+#NOTIFIER__ADAPTERS_0__endpoint=http://127.0.0.1:3020/webhook
+#NOTIFIER__ADAPTERS_0__auth_token=your-auth-token
+#NOTIFIER__ADAPTERS_0__max_retries=3
+#NOTIFIER__ADAPTERS_0__timeout=50
+#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_server=server-value
+#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_client=client-value
+#
+## kafka adapter index 1
+#NOTIFIER__ADAPTERS_1__type=Kafka
+#NOTIFIER__ADAPTERS_1__brokers=localhost:9092
+#NOTIFIER__ADAPTERS_1__topic=notifications
+#NOTIFIER__ADAPTERS_1__max_retries=3
+#NOTIFIER__ADAPTERS_1__timeout=60
+#
+## mqtt adapter index 2
+#NOTIFIER__ADAPTERS_2__type=Mqtt
+#NOTIFIER__ADAPTERS_2__broker=mqtt.example.com
+#NOTIFIER__ADAPTERS_2__port=1883
+#NOTIFIER__ADAPTERS_2__client_id=event-notifier
+#NOTIFIER__ADAPTERS_2__topic=events
+#NOTIFIER__ADAPTERS_2__max_retries=3

crates/event/examples/.env.zh.example

@@ -0,0 +1,28 @@
+## ===== 全局配置 =====
+#NOTIFIER__STORE_PATH=/var/log/event-notification
+#NOTIFIER__CHANNEL_CAPACITY=5000
+#
+## ===== 适配器配置（数组格式） =====
+## Webhook 适配器（索引 0）
+#NOTIFIER__ADAPTERS_0__type=Webhook
+#NOTIFIER__ADAPTERS_0__endpoint=http://127.0.0.1:3020/webhook
+#NOTIFIER__ADAPTERS_0__auth_token=your-auth-token
+#NOTIFIER__ADAPTERS_0__max_retries=3
+#NOTIFIER__ADAPTERS_0__timeout=50
+#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_server=value
+#NOTIFIER__ADAPTERS_0__custom_headers__x_custom_client=value
+#
+## Kafka 适配器（索引 1）
+#NOTIFIER__ADAPTERS_1__type=Kafka
+#NOTIFIER__ADAPTERS_1__brokers=localhost:9092
+#NOTIFIER__ADAPTERS_1__topic=notifications
+#NOTIFIER__ADAPTERS_1__max_retries=3
+#NOTIFIER__ADAPTERS_1__timeout=60
+#
+## MQTT 适配器（索引 2）
+#NOTIFIER__ADAPTERS_2__type=Mqtt
+#NOTIFIER__ADAPTERS_2__broker=mqtt.example.com
+#NOTIFIER__ADAPTERS_2__port=1883
+#NOTIFIER__ADAPTERS_2__client_id=event-notifier
+#NOTIFIER__ADAPTERS_2__topic=events
+#NOTIFIER__ADAPTERS_2__max_retries=3

crates/event/examples/event.toml

@@ -0,0 +1,29 @@
+# config.toml
+store_path = "/var/log/event-notifier"
+channel_capacity = 5000
+
+[[adapters]]
+type = "Webhook"
+endpoint = "http://127.0.0.1:3020/webhook"
+auth_token = "your-auth-token"
+max_retries = 3
+timeout = 50
+
+[adapters.custom_headers]
+custom_server = "value_server"
+custom_client = "value_client"
+
+[[adapters]]
+type = "Kafka"
+brokers = "localhost:9092"
+topic = "notifications"
+max_retries = 3
+timeout = 60
+
+[[adapters]]
+type = "Mqtt"
+broker = "mqtt.example.com"
+port = 1883
+client_id = "event-notifier"
+topic = "events"
+max_retries = 3

crates/event/examples/full.rs

@@ -0,0 +1,133 @@
+use rustfs_event::{
+    AdapterConfig, Bucket, Error as NotifierError, Event, Identity, Metadata, Name, NotifierConfig, Object, Source, WebhookConfig,
+};
+use std::collections::HashMap;
+use tokio::signal;
+use tracing::Level;
+use tracing_subscriber::FmtSubscriber;
+
+async fn setup_notification_system() -> Result<(), NotifierError> {
+    let config = NotifierConfig {
+        store_path: "./deploy/logs/event_store".into(),
+        channel_capacity: 100,
+        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
+            endpoint: "http://127.0.0.1:3020/webhook".into(),
+            auth_token: Some("your-auth-token".into()),
+            custom_headers: Some(HashMap::new()),
+            max_retries: 3,
+            timeout: 30,
+        })],
+    };
+
+    rustfs_event::initialize(config).await?;
+
+    // wait for the system to be ready
+    for _ in 0..50 {
+        // wait up to 5 seconds
+        if rustfs_event::is_ready() {
+            return Ok(());
+        }
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+    }
+
+    Err(NotifierError::custom("notify the system of initialization timeout"))
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // initialization log
+    // tracing_subscriber::fmt::init();
+
+    let subscriber = FmtSubscriber::builder()
+        .with_max_level(Level::DEBUG) // set to debug or lower level
+        .with_target(false) // simplify output
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).expect("failed to set up log subscriber");
+
+    // set up notification system
+    if let Err(e) = setup_notification_system().await {
+        eprintln!("unable to initialize notification system:{}", e);
+        return Err(e.into());
+    }
+
+    // create a shutdown signal processing
+    let (shutdown_tx, mut shutdown_rx) = tokio::sync::oneshot::channel();
+
+    // start signal processing task
+    tokio::spawn(async move {
+        let _ = signal::ctrl_c().await;
+        println!("Received the shutdown signal and prepared to exit...");
+        let _ = shutdown_tx.send(());
+    });
+
+    // main application logic
+    tokio::select! {
+        _ = async {
+            loop {
+                // application logic
+                // create an s3 metadata object
+                let metadata = Metadata {
+                    schema_version: "1.0".to_string(),
+                    configuration_id: "test-config".to_string(),
+                    bucket: Bucket {
+                        name: "my-bucket".to_string(),
+                        owner_identity: Identity {
+                            principal_id: "owner123".to_string(),
+                        },
+                        arn: "arn:aws:s3:::my-bucket".to_string(),
+                    },
+                    object: Object {
+                        key: "test.txt".to_string(),
+                        size: Some(1024),
+                        etag: Some("abc123".to_string()),
+                        content_type: Some("text/plain".to_string()),
+                        user_metadata: None,
+                        version_id: None,
+                        sequencer: "1234567890".to_string(),
+                    },
+                };
+
+                // create source object
+                let source = Source {
+                    host: "localhost".to_string(),
+                    port: "80".to_string(),
+                    user_agent: "curl/7.68.0".to_string(),
+                };
+
+                // create events using builder mode
+                let event = Event::builder()
+                    .event_time("2023-10-01T12:00:00.000Z")
+                    .event_name(Name::ObjectCreatedPut)
+                    .user_identity(Identity {
+                        principal_id: "user123".to_string(),
+                    })
+                    .s3(metadata)
+                    .source(source)
+                    .channels(vec!["webhook".to_string()])
+                    .build()
+                    .expect("failed to create event");
+
+                if let Err(e) = rustfs_event::send_event(event).await {
+                    eprintln!("send event failed:{}", e);
+                }
+
+                tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
+            }
+        } => {},
+
+        _ = &mut shutdown_rx => {
+            println!("close the app");
+        }
+    }
+
+    // 优雅关闭通知系统
+    println!("turn off the notification system");
+    if let Err(e) = rustfs_event::shutdown().await {
+        eprintln!("An error occurred while shutting down the notification system:{}", e);
+    } else {
+        println!("the notification system has been closed safely");
+    }
+
+    println!("the application has been closed safely");
+    Ok(())
+}

crates/event/examples/simple.rs

@@ -0,0 +1,110 @@
+use rustfs_event::create_adapters;
+use rustfs_event::NotifierSystem;
+use rustfs_event::{AdapterConfig, NotifierConfig, WebhookConfig};
+use rustfs_event::{Bucket, Event, Identity, Metadata, Name, Object, Source};
+use std::collections::HashMap;
+use std::error;
+use std::sync::Arc;
+use tokio::signal;
+use tracing::Level;
+use tracing_subscriber::FmtSubscriber;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn error::Error>> {
+    let subscriber = FmtSubscriber::builder()
+        .with_max_level(Level::DEBUG) // set to debug or lower level
+        .with_target(false) // simplify output
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).expect("failed to set up log subscriber");
+
+    let config = NotifierConfig {
+        store_path: "./events".to_string(),
+        channel_capacity: 100,
+        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
+            endpoint: "http://127.0.0.1:3020/webhook".to_string(),
+            auth_token: Some("secret-token".to_string()),
+            custom_headers: Some(HashMap::from([("X-Custom".to_string(), "value".to_string())])),
+            max_retries: 3,
+            timeout: 10,
+        })],
+    };
+
+    // event_load_config
+    // loading configuration from environment variables
+    let _config = NotifierConfig::event_load_config(Some("./crates/event-notifier/examples/event.toml".to_string()));
+    tracing::info!("event_load_config config: {:?} \n", _config);
+    dotenvy::dotenv()?;
+    let _config = NotifierConfig::event_load_config(None);
+    tracing::info!("event_load_config config: {:?} \n", _config);
+    let system = Arc::new(tokio::sync::Mutex::new(NotifierSystem::new(config.clone()).await?));
+    let adapters = create_adapters(&config.adapters)?;
+
+    // create an s3 metadata object
+    let metadata = Metadata {
+        schema_version: "1.0".to_string(),
+        configuration_id: "test-config".to_string(),
+        bucket: Bucket {
+            name: "my-bucket".to_string(),
+            owner_identity: Identity {
+                principal_id: "owner123".to_string(),
+            },
+            arn: "arn:aws:s3:::my-bucket".to_string(),
+        },
+        object: Object {
+            key: "test.txt".to_string(),
+            size: Some(1024),
+            etag: Some("abc123".to_string()),
+            content_type: Some("text/plain".to_string()),
+            user_metadata: None,
+            version_id: None,
+            sequencer: "1234567890".to_string(),
+        },
+    };
+
+    // create source object
+    let source = Source {
+        host: "localhost".to_string(),
+        port: "80".to_string(),
+        user_agent: "curl/7.68.0".to_string(),
+    };
+
+    // create events using builder mode
+    let event = Event::builder()
+        .event_time("2023-10-01T12:00:00.000Z")
+        .event_name(Name::ObjectCreatedPut)
+        .user_identity(Identity {
+            principal_id: "user123".to_string(),
+        })
+        .s3(metadata)
+        .source(source)
+        .channels(vec!["webhook".to_string()])
+        .build()
+        .expect("failed to create event");
+
+    {
+        let system = system.lock().await;
+        system.send_event(event).await?;
+    }
+
+    let system_clone = Arc::clone(&system);
+    let system_handle = tokio::spawn(async move {
+        let mut system = system_clone.lock().await;
+        system.start(adapters).await
+    });
+
+    signal::ctrl_c().await?;
+    tracing::info!("Received shutdown signal");
+    let result = {
+        let mut system = system.lock().await;
+        system.shutdown().await
+    };
+
+    if let Err(e) = result {
+        tracing::error!("Failed to shut down the notification system: {}", e);
+    } else {
+        tracing::info!("Notification system shut down successfully");
+    }
+
+    system_handle.await??;
+    Ok(())
+}

crates/event/examples/webhook.rs

@@ -0,0 +1,94 @@
+use axum::{extract::Json, http::StatusCode, routing::post, Router};
+use serde_json::Value;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[tokio::main]
+async fn main() {
+    // 构建应用
+    let app = Router::new().route("/webhook", post(receive_webhook));
+    // 启动服务器
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3020").await.unwrap();
+    println!("Server running on http://0.0.0.0:3020");
+
+    // 创建关闭信号处理
+    tokio::select! {
+        result = axum::serve(listener, app) => {
+            if let Err(e) = result {
+                eprintln!("Server error: {}", e);
+            }
+        }
+        _ = tokio::signal::ctrl_c() => {
+            println!("Shutting down server...");
+        }
+    }
+}
+
+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");
+
+    // get the number of seconds since the unix era
+    let seconds = since_the_epoch.as_secs();
+
+    // Manually calculate year, month, day, hour, minute, and second
+    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!(
+        "received a webhook request time:{} content:\n {}",
+        seconds,
+        serde_json::to_string_pretty(&payload).unwrap()
+    );
+    StatusCode::OK
+}
+
+fn convert_seconds_to_date(seconds: u64) -> (u32, u32, u32, u32, u32, u32) {
+    // assume that the time zone is utc
+    let seconds_per_minute = 60;
+    let seconds_per_hour = 3600;
+    let seconds_per_day = 86400;
+
+    // Calculate the year, month, day, hour, minute, and second corresponding to the number of seconds
+    let mut total_seconds = seconds;
+    let mut year = 1970;
+    let mut month = 1;
+    let mut day = 1;
+    let mut hour = 0;
+    let mut minute = 0;
+    let mut second = 0;
+
+    // calculate year
+    while total_seconds >= 31536000 {
+        year += 1;
+        total_seconds -= 31536000; // simplified processing no leap year considered
+    }
+
+    // calculate month
+    let days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    for m in &days_in_month {
+        if total_seconds >= m * seconds_per_day {
+            month += 1;
+            total_seconds -= m * seconds_per_day;
+        } else {
+            break;
+        }
+    }
+
+    // calculate the number of days
+    day += total_seconds / seconds_per_day;
+    total_seconds %= seconds_per_day;
+
+    // calculate hours
+    hour += total_seconds / seconds_per_hour;
+    total_seconds %= seconds_per_hour;
+
+    // calculate minutes
+    minute += total_seconds / seconds_per_minute;
+    total_seconds %= seconds_per_minute;
+
+    // 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)
+}