gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-08-25 13:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

improve code for notify

Browse Source
This commit is contained in:
houseme
2025-06-21 10:35:07 +08:00
parent 48d530cb13
commit e0f65e5e24
14 changed files with 442 additions and 634 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/notify/src/factory.rs
+161 -107
View File
@@ -1,27 +1,106 @@
use crate::store::DEFAULT_LIMIT;
use crate::{
config::KVS,
error::TargetError,
target::{mqtt::MQTTArgs, webhook::WebhookArgs, Target},
};
use async_trait::async_trait;
use ecstore::config::KVS;
use rumqttc::QoS;
use std::time::Duration;
use tracing::warn;
use url::Url;
// --- Configuration Constants ---
// General
pub const ENABLE: &str = "enable";
pub const DEFAULT_TARGET: &str = "1";
#[allow(dead_code)]
pub const NOTIFY_KAFKA_SUB_SYS: &str = "notify_kafka";
#[allow(dead_code)]
pub const NOTIFY_MQTT_SUB_SYS: &str = "notify_mqtt";
#[allow(dead_code)]
pub const NOTIFY_MY_SQL_SUB_SYS: &str = "notify_mysql";
#[allow(dead_code)]
pub const NOTIFY_NATS_SUB_SYS: &str = "notify_nats";
#[allow(dead_code)]
pub const NOTIFY_NSQ_SUB_SYS: &str = "notify_nsq";
#[allow(dead_code)]
pub const NOTIFY_ES_SUB_SYS: &str = "notify_elasticsearch";
#[allow(dead_code)]
pub const NOTIFY_AMQP_SUB_SYS: &str = "notify_amqp";
#[allow(dead_code)]
pub const NOTIFY_POSTGRES_SUB_SYS: &str = "notify_postgres";
#[allow(dead_code)]
pub const NOTIFY_REDIS_SUB_SYS: &str = "notify_redis";
pub const NOTIFY_WEBHOOK_SUB_SYS: &str = "notify_webhook";
// Webhook Keys
pub const WEBHOOK_ENDPOINT: &str = "endpoint";
pub const WEBHOOK_AUTH_TOKEN: &str = "auth_token";
pub const WEBHOOK_QUEUE_LIMIT: &str = "queue_limit";
pub const WEBHOOK_QUEUE_DIR: &str = "queue_dir";
pub const WEBHOOK_CLIENT_CERT: &str = "client_cert";
pub const WEBHOOK_CLIENT_KEY: &str = "client_key";
// Webhook Environment Variables
const ENV_WEBHOOK_ENABLE: &str = "RUSTFS_NOTIFY_WEBHOOK_ENABLE";
const ENV_WEBHOOK_ENDPOINT: &str = "RUSTFS_NOTIFY_WEBHOOK_ENDPOINT";
const ENV_WEBHOOK_AUTH_TOKEN: &str = "RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN";
const ENV_WEBHOOK_QUEUE_LIMIT: &str = "RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT";
const ENV_WEBHOOK_QUEUE_DIR: &str = "RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR";
const ENV_WEBHOOK_CLIENT_CERT: &str = "RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT";
const ENV_WEBHOOK_CLIENT_KEY: &str = "RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY";
// MQTT Keys
pub const MQTT_BROKER: &str = "broker";
pub const MQTT_TOPIC: &str = "topic";
pub const MQTT_QOS: &str = "qos";
pub const MQTT_USERNAME: &str = "username";
pub const MQTT_PASSWORD: &str = "password";
pub const MQTT_RECONNECT_INTERVAL: &str = "reconnect_interval";
pub const MQTT_KEEP_ALIVE_INTERVAL: &str = "keep_alive_interval";
pub const MQTT_QUEUE_DIR: &str = "queue_dir";
pub const MQTT_QUEUE_LIMIT: &str = "queue_limit";
// MQTT Environment Variables
const ENV_MQTT_ENABLE: &str = "RUSTFS_NOTIFY_MQTT_ENABLE";
const ENV_MQTT_BROKER: &str = "RUSTFS_NOTIFY_MQTT_BROKER";
const ENV_MQTT_TOPIC: &str = "RUSTFS_NOTIFY_MQTT_TOPIC";
const ENV_MQTT_QOS: &str = "RUSTFS_NOTIFY_MQTT_QOS";
const ENV_MQTT_USERNAME: &str = "RUSTFS_NOTIFY_MQTT_USERNAME";
const ENV_MQTT_PASSWORD: &str = "RUSTFS_NOTIFY_MQTT_PASSWORD";
const ENV_MQTT_RECONNECT_INTERVAL: &str = "RUSTFS_NOTIFY_MQTT_RECONNECT_INTERVAL";
const ENV_MQTT_KEEP_ALIVE_INTERVAL: &str = "RUSTFS_NOTIFY_MQTT_KEEP_ALIVE_INTERVAL";
const ENV_MQTT_QUEUE_DIR: &str = "RUSTFS_NOTIFY_MQTT_QUEUE_DIR";
const ENV_MQTT_QUEUE_LIMIT: &str = "RUSTFS_NOTIFY_MQTT_QUEUE_LIMIT";
/// Helper function to get values from environment variables or KVS configurations.
///
/// It will give priority to reading from environment variables such as `BASE_ENV_KEY_ID` and fall back to the KVS configuration if it fails.
fn get_config_value(id: &str, base_env_key: &str, config_key: &str, config: &KVS) -> Option<String> {
let env_key = if id != DEFAULT_TARGET {
format!("{}_{}", base_env_key, id.to_uppercase().replace('-', "_"))
} else {
base_env_key.to_string()
};
match std::env::var(&env_key) {
Ok(val) => Some(val),
Err(_) => config.lookup(config_key),
}
}
/// Trait for creating targets from configuration
#[async_trait]
pub trait TargetFactory: Send + Sync {
/// Creates a target from configuration
async fn create_target(
&self,
id: String,
config: &KVS,
) -> Result<Box<dyn Target + Send + Sync>, TargetError>;
async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError>;
/// Validates target configuration
fn validate_config(&self, config: &KVS) -> Result<(), TargetError>;
fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError>;
}
/// Factory for creating Webhook targets
@@ -29,35 +108,32 @@ pub struct WebhookTargetFactory;
#[async_trait]
impl TargetFactory for WebhookTargetFactory {
async fn create_target(
&self,
id: String,
config: &KVS,
) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
// Parse configuration values
let enable = config.lookup("enable").unwrap_or("off") == "on";
async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
let get = |base_env_key: &str, config_key: &str| get_config_value(&id, base_env_key, config_key, config);
let enable = get(ENV_WEBHOOK_ENABLE, ENABLE)
.map(|v| v.eq_ignore_ascii_case("on") || v.eq_ignore_ascii_case("true"))
.unwrap_or(false);
if !enable {
return Err(TargetError::Configuration("Target is disabled".to_string()));
}
let endpoint = config
.lookup("endpoint")
.ok_or_else(|| TargetError::Configuration("Missing endpoint".to_string()))?;
let endpoint_url = Url::parse(endpoint)
.map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
let endpoint = get(ENV_WEBHOOK_ENDPOINT, WEBHOOK_ENDPOINT)
.ok_or_else(|| TargetError::Configuration("Missing webhook endpoint".to_string()))?;
let endpoint_url =
Url::parse(&endpoint).map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
let auth_token = config.lookup("auth_token").unwrap_or("").to_string();
let queue_dir = config.lookup("queue_dir").unwrap_or("").to_string();
let auth_token = get(ENV_WEBHOOK_AUTH_TOKEN, WEBHOOK_AUTH_TOKEN).unwrap_or_default();
let queue_dir = get(ENV_WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_DIR).unwrap_or_default();
let queue_limit = config
.lookup("queue_limit")
let queue_limit = get(ENV_WEBHOOK_QUEUE_LIMIT, WEBHOOK_QUEUE_LIMIT)
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(DEFAULT_LIMIT);
let client_cert = config.lookup("client_cert").unwrap_or("").to_string();
let client_key = config.lookup("client_key").unwrap_or("").to_string();
let client_cert = get(ENV_WEBHOOK_CLIENT_CERT, WEBHOOK_CLIENT_CERT).unwrap_or_default();
let client_key = get(ENV_WEBHOOK_CLIENT_KEY, WEBHOOK_CLIENT_KEY).unwrap_or_default();
// Create and return Webhook target
let args = WebhookArgs {
enable,
endpoint: endpoint_url,
@@ -72,38 +148,33 @@ impl TargetFactory for WebhookTargetFactory {
Ok(Box::new(target))
}
fn validate_config(&self, config: &KVS) -> Result<(), TargetError> {
let enable = config.lookup("enable").unwrap_or("off") == "on";
fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError> {
let get = |base_env_key: &str, config_key: &str| get_config_value(id, base_env_key, config_key, config);
let enable = get(ENV_WEBHOOK_ENABLE, ENABLE)
.map(|v| v.eq_ignore_ascii_case("on") || v.eq_ignore_ascii_case("true"))
.unwrap_or(false);
if !enable {
return Ok(());
}
// Validate endpoint
let endpoint = config
.lookup("endpoint")
.ok_or_else(|| TargetError::Configuration("Missing endpoint".to_string()))?;
Url::parse(endpoint)
.map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
let endpoint = get(ENV_WEBHOOK_ENDPOINT, WEBHOOK_ENDPOINT)
.ok_or_else(|| TargetError::Configuration("Missing webhook endpoint".to_string()))?;
Url::parse(&endpoint).map_err(|e| TargetError::Configuration(format!("Invalid endpoint URL: {}", e)))?;
// Validate TLS certificates
let client_cert = config.lookup("client_cert").unwrap_or("");
let client_key = config.lookup("client_key").unwrap_or("");
let client_cert = get(ENV_WEBHOOK_CLIENT_CERT, WEBHOOK_CLIENT_CERT).unwrap_or_default();
let client_key = get(ENV_WEBHOOK_CLIENT_KEY, WEBHOOK_CLIENT_KEY).unwrap_or_default();
if (!client_cert.is_empty() && client_key.is_empty())
|| (client_cert.is_empty() && !client_key.is_empty())
{
if client_cert.is_empty() != client_key.is_empty() {
return Err(TargetError::Configuration(
"Both client_cert and client_key must be specified if using client certificates"
.to_string(),
"Both client_cert and client_key must be specified together".to_string(),
));
}
// Validate queue directory
let queue_dir = config.lookup("queue_dir").unwrap_or("");
if !queue_dir.is_empty() && !std::path::Path::new(queue_dir).is_absolute() {
return Err(TargetError::Configuration(
"Webhook Queue directory must be an absolute path".to_string(),
));
let queue_dir = get(ENV_WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_DIR).unwrap_or_default();
if !queue_dir.is_empty() && !std::path::Path::new(&queue_dir).is_absolute() {
return Err(TargetError::Configuration("Webhook queue directory must be an absolute path".to_string()));
}
Ok(())
@@ -115,64 +186,56 @@ pub struct MQTTTargetFactory;
#[async_trait]
impl TargetFactory for MQTTTargetFactory {
async fn create_target(
&self,
id: String,
config: &KVS,
) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
// Parse configuration values
let enable = config.lookup("enable").unwrap_or("off") == "on";
async fn create_target(&self, id: String, config: &KVS) -> Result<Box<dyn Target + Send + Sync>, TargetError> {
let get = |base_env_key: &str, config_key: &str| get_config_value(&id, base_env_key, config_key, config);
let enable = get(ENV_MQTT_ENABLE, ENABLE)
.map(|v| v.eq_ignore_ascii_case("on") || v.eq_ignore_ascii_case("true"))
.unwrap_or(false);
if !enable {
return Err(TargetError::Configuration("Target is disabled".to_string()));
}
let broker = config
.lookup("broker")
.ok_or_else(|| TargetError::Configuration("Missing broker".to_string()))?;
let broker_url = Url::parse(broker)
.map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
let broker =
get(ENV_MQTT_BROKER, MQTT_BROKER).ok_or_else(|| TargetError::Configuration("Missing MQTT broker".to_string()))?;
let broker_url = Url::parse(&broker).map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
let topic = config
.lookup("topic")
.ok_or_else(|| TargetError::Configuration("Missing topic".to_string()))?;
let topic =
get(ENV_MQTT_TOPIC, MQTT_TOPIC).ok_or_else(|| TargetError::Configuration("Missing MQTT topic".to_string()))?;
let qos = config
.lookup("qos")
let qos = get(ENV_MQTT_QOS, MQTT_QOS)
.and_then(|v| v.parse::<u8>().ok())
.map(|q| match q {
0 => QoS::AtMostOnce,
1 => QoS::AtLeastOnce,
2 => QoS::ExactlyOnce,
_ => QoS::AtMostOnce,
_ => QoS::AtLeastOnce,
})
.unwrap_or(QoS::AtLeastOnce);
let username = config.lookup("username").unwrap_or("").to_string();
let password = config.lookup("password").unwrap_or("").to_string();
let username = get(ENV_MQTT_USERNAME, MQTT_USERNAME).unwrap_or_default();
let password = get(ENV_MQTT_PASSWORD, MQTT_PASSWORD).unwrap_or_default();
let reconnect_interval = config
.lookup("reconnect_interval")
let reconnect_interval = get(ENV_MQTT_RECONNECT_INTERVAL, MQTT_RECONNECT_INTERVAL)
.and_then(|v| v.parse::<u64>().ok())
.map(Duration::from_secs)
.unwrap_or(Duration::from_secs(5));
.unwrap_or_else(|| Duration::from_secs(5));
let keep_alive = config
.lookup("keep_alive_interval")
let keep_alive = get(ENV_MQTT_KEEP_ALIVE_INTERVAL, MQTT_KEEP_ALIVE_INTERVAL)
.and_then(|v| v.parse::<u64>().ok())
.map(Duration::from_secs)
.unwrap_or(Duration::from_secs(30));
.unwrap_or_else(|| Duration::from_secs(30));
let queue_dir = config.lookup("queue_dir").unwrap_or("").to_string();
let queue_limit = config
.lookup("queue_limit")
let queue_dir = get(ENV_MQTT_QUEUE_DIR, MQTT_QUEUE_DIR).unwrap_or_default();
let queue_limit = get(ENV_MQTT_QUEUE_LIMIT, MQTT_QUEUE_LIMIT)
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(DEFAULT_LIMIT);
// Create and return MQTT target
let args = MQTTArgs {
enable,
broker: broker_url,
topic: topic.to_string(),
topic,
qos,
username,
password,
@@ -186,56 +249,47 @@ impl TargetFactory for MQTTTargetFactory {
Ok(Box::new(target))
}
fn validate_config(&self, config: &KVS) -> Result<(), TargetError> {
let enable = config.lookup("enable").unwrap_or("off") == "on";
fn validate_config(&self, id: &str, config: &KVS) -> Result<(), TargetError> {
let get = |base_env_key: &str, config_key: &str| get_config_value(id, base_env_key, config_key, config);
let enable = get(ENV_MQTT_ENABLE, ENABLE)
.map(|v| v.eq_ignore_ascii_case("on") || v.eq_ignore_ascii_case("true"))
.unwrap_or(false);
if !enable {
return Ok(());
}
// Validate broker URL
let broker = config
.lookup("broker")
.ok_or_else(|| TargetError::Configuration("Missing broker".to_string()))?;
let url = Url::parse(broker)
.map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
let broker =
get(ENV_MQTT_BROKER, MQTT_BROKER).ok_or_else(|| TargetError::Configuration("Missing MQTT broker".to_string()))?;
let url = Url::parse(&broker).map_err(|e| TargetError::Configuration(format!("Invalid broker URL: {}", e)))?;
// Validate supported schemes
match url.scheme() {
"tcp" | "ssl" | "ws" | "wss" | "mqtt" | "mqtts" => {}
_ => {
return Err(TargetError::Configuration(
"Unsupported broker URL scheme".to_string(),
));
return Err(TargetError::Configuration("Unsupported broker URL scheme".to_string()));
}
}
// Validate topic
if config.lookup("topic").is_none() {
return Err(TargetError::Configuration("Missing topic".to_string()));
if get(ENV_MQTT_TOPIC, MQTT_TOPIC).is_none() {
return Err(TargetError::Configuration("Missing MQTT topic".to_string()));
}
// Validate QoS
if let Some(qos_str) = config.lookup("qos") {
if let Some(qos_str) = get(ENV_MQTT_QOS, MQTT_QOS) {
let qos = qos_str
.parse::<u8>()
.map_err(|_| TargetError::Configuration("Invalid QoS value".to_string()))?;
if qos > 2 {
return Err(TargetError::Configuration(
"QoS must be 0, 1, or 2".to_string(),
));
return Err(TargetError::Configuration("QoS must be 0, 1, or 2".to_string()));
}
}
// Validate queue directory
let queue_dir = config.lookup("queue_dir").unwrap_or("");
let queue_dir = get(ENV_MQTT_QUEUE_DIR, MQTT_QUEUE_DIR).unwrap_or_default();
if !queue_dir.is_empty() {
if !std::path::Path::new(queue_dir).is_absolute() {
return Err(TargetError::Configuration(
"mqtt Queue directory must be an absolute path".to_string(),
));
if !std::path::Path::new(&queue_dir).is_absolute() {
return Err(TargetError::Configuration("MQTT queue directory must be an absolute path".to_string()));
}
if let Some(qos_str) = config.lookup("qos") {
if let Some(qos_str) = get(ENV_MQTT_QOS, MQTT_QOS) {
if qos_str == "0" {
warn!("Using queue_dir with QoS 0 may result in event loss");
}