gsadmin/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-08-27 15:37:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add an opt-in NATS JetStream publish path for the notify and audit targets (#4634)

Browse Source 
feat(targets): add an opt-in NATS JetStream publish path for the notify and audit targets

The NATS notify and audit targets publish through NATS Core, which returns
before the server has durably accepted the message. A broker restart or a
connection drop between the publish and the flush loses the event, even though
the send queue has already cleared it, and no acknowledgement gates that clear.

An opt-in JetStream publish path clears a queued event only after the server
returns a durable PublishAck, so delivery is at-least-once across a broker
restart or a reconnect. It applies to both the notify and audit NATS targets, is
off by default, and is byte-identical to the NATS Core path when disabled.

The path includes durable store-and-forward, a stable dedup id sent as the
Nats-Msg-Id header so a replayed event is collapsed by the stream duplicate
window, pre-flight stream validation, and a bounded failed-events store for
terminally-failed and retry-exhausted events. Three configuration keys per
target select it: JETSTREAM_ENABLE, JETSTREAM_STREAM_NAME, and
JETSTREAM_ACK_TIMEOUT_SECS, under the RUSTFS_NOTIFY_NATS_ and RUSTFS_AUDIT_NATS_
prefixes.

The on-disk batch filename separator changes from colon to underscore so
batch names are valid on Windows filesystems, with transparent read-back
of files written under the previous separator. The migration affects the
shared queue store for every target type and lands with this feature
because the store gains its first Windows-exercised paths here.

Co-authored-by: houseme <housemecn@gmail.com>
This commit is contained in:
escapecode
2026-07-14 08:36:14 +01:00
committed by GitHub
parent 25f81f812c
commit a80699b6dd
41 changed files with 6191 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/targets/src/config/common.rs
+176 -6
View File
@@ -13,13 +13,15 @@
// limitations under the License.
use crate::TargetError;
use crate::target::nats::validate_jetstream_settings;
use crate::target::pulsar::validate_pulsar_broker;
use async_nats::ServerAddr;
use rustfs_config::server_config::KVS;
use rustfs_config::{
DEFAULT_DELIMITER, ENABLE_KEY, EnableState, NATS_CREDENTIALS_FILE, NATS_PASSWORD, NATS_QUEUE_DIR, NATS_SUBJECT, NATS_TLS_CA,
NATS_TLS_CLIENT_CERT, NATS_TLS_CLIENT_KEY, NATS_TOKEN, NATS_USERNAME, PULSAR_AUTH_TOKEN, PULSAR_PASSWORD, PULSAR_QUEUE_DIR,
PULSAR_TLS_CA, PULSAR_TOPIC, PULSAR_USERNAME,
DEFAULT_DELIMITER, ENABLE_KEY, EnableState, NATS_CREDENTIALS_FILE, NATS_JETSTREAM_ACK_TIMEOUT_SECS, NATS_JETSTREAM_ENABLE,
NATS_JETSTREAM_STREAM_NAME, NATS_PASSWORD, NATS_QUEUE_DIR, NATS_SUBJECT, NATS_TLS_CA, NATS_TLS_CLIENT_CERT,
NATS_TLS_CLIENT_KEY, NATS_TOKEN, NATS_USERNAME, PULSAR_AUTH_TOKEN, PULSAR_PASSWORD, PULSAR_QUEUE_DIR, PULSAR_TLS_CA,
PULSAR_TOPIC, PULSAR_USERNAME,
};
use rustfs_utils::egress::validate_outbound_url;
use std::collections::HashSet;
@@ -130,10 +132,42 @@ pub(super) fn validate_nats_server_config(server: &ServerAddr, config: &KVS, def
return Err(TargetError::Configuration("NATS queue directory must be an absolute path".to_string()));
}
let jetstream_enable = parse_jetstream_enable(config)?.unwrap_or(false);
let jetstream_stream_name = config.lookup(NATS_JETSTREAM_STREAM_NAME).unwrap_or_default();
let jetstream_ack_timeout_secs = parse_jetstream_ack_timeout_secs(config)?;
validate_jetstream_settings(jetstream_enable, &jetstream_stream_name, &queue_dir, jetstream_ack_timeout_secs)?;
let _ = server;
Ok(())
}
/// Parses the jetstream_enable flag, distinguishing an absent or blank key (None, disabled) from a
/// key that is present but carries an unparsable value, which is a configuration error rather than
/// a silent disable. Unwrapping an unparsable value to disabled would drop the durability guarantee
/// the operator asked for with no signal.
pub(super) fn parse_jetstream_enable(config: &KVS) -> Result<Option<bool>, TargetError> {
match config.lookup(NATS_JETSTREAM_ENABLE) {
Some(value) if !value.trim().is_empty() => parse_target_bool(Some(value.as_str())).map(Some).ok_or_else(|| {
TargetError::Configuration(format!(
"Invalid {NATS_JETSTREAM_ENABLE} boolean value: {value} (accepted values include on, off, true, false, yes, no, 1, 0)"
))
}),
_ => Ok(None),
}
}
pub(super) fn parse_jetstream_ack_timeout_secs(config: &KVS) -> Result<Option<u64>, TargetError> {
match config.lookup(NATS_JETSTREAM_ACK_TIMEOUT_SECS) {
Some(value) if !value.trim().is_empty() => {
let secs = value.trim().parse::<u64>().map_err(|_| {
TargetError::Configuration(format!("{NATS_JETSTREAM_ACK_TIMEOUT_SECS} must be a whole number of seconds"))
})?;
Ok(Some(secs))
}
_ => Ok(None),
}
}
pub(super) fn validate_pulsar_broker_config(broker: &str, config: &KVS, default_queue_dir: &str) -> Result<(), TargetError> {
let url = validate_pulsar_broker(broker)?;
@@ -193,15 +227,26 @@ pub(super) fn validate_outbound_http_url(value: &Url, field_label: &str) -> Resu
#[cfg(test)]
mod tests {
use super::{validate_nats_server_config, validate_pulsar_broker_config};
use super::{parse_jetstream_enable, validate_nats_server_config, validate_pulsar_broker_config};
use async_nats::ServerAddr;
use rustfs_config::server_config::KVS;
use rustfs_config::{
NATS_PASSWORD, NATS_QUEUE_DIR, NATS_SUBJECT, NATS_TOKEN, NATS_USERNAME, PULSAR_TLS_ALLOW_INSECURE, PULSAR_TLS_CA,
PULSAR_TLS_HOSTNAME_VERIFICATION, PULSAR_TOPIC,
NATS_JETSTREAM_ACK_TIMEOUT_SECS, NATS_JETSTREAM_ENABLE, NATS_JETSTREAM_STREAM_NAME, NATS_PASSWORD, NATS_QUEUE_DIR,
NATS_SUBJECT, NATS_TOKEN, NATS_USERNAME, PULSAR_TLS_ALLOW_INSECURE, PULSAR_TLS_CA, PULSAR_TLS_HOSTNAME_VERIFICATION,
PULSAR_TOPIC,
};
use std::str::FromStr;
fn nats_server() -> ServerAddr {
ServerAddr::from_str("nats://127.0.0.1:4222").expect("valid nats address")
}
// Absolute on Linux, macOS, and Windows. temp_dir needs no filesystem to exist for a
// validation-only test, and Path::is_absolute stays true across platforms.
fn nats_queue_dir() -> String {
std::env::temp_dir().join("rustfs-nats-queue").to_string_lossy().into_owned()
}
#[test]
fn validate_nats_server_config_rejects_multiple_auth_methods() {
let server = ServerAddr::from_str("nats://127.0.0.1:4222").expect("valid nats address");
@@ -228,6 +273,131 @@ mod tests {
assert!(err.to_string().contains("absolute path"));
}
#[test]
fn validate_nats_server_config_rejects_jetstream_without_stream() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_QUEUE_DIR.to_string(), nats_queue_dir());
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "on".to_string());
let err = validate_nats_server_config(&nats_server(), &config, "")
.expect_err("enabled jetstream without a stream should be rejected");
assert!(err.to_string().contains(NATS_JETSTREAM_STREAM_NAME));
}
#[test]
fn validate_nats_server_config_rejects_jetstream_without_queue_dir() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "on".to_string());
config.insert(NATS_JETSTREAM_STREAM_NAME.to_string(), "RUSTFS_EVENTS".to_string());
let err = validate_nats_server_config(&nats_server(), &config, "")
.expect_err("enabled jetstream without a queue_dir should be rejected");
assert!(err.to_string().contains(NATS_QUEUE_DIR));
}
#[test]
fn validate_nats_server_config_rejects_out_of_range_ack_timeout() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_JETSTREAM_ACK_TIMEOUT_SECS.to_string(), "5".to_string());
let err =
validate_nats_server_config(&nats_server(), &config, "").expect_err("out-of-range ack timeout should be rejected");
assert!(err.to_string().contains("between"));
}
#[test]
fn validate_nats_server_config_accepts_enabled_jetstream_with_stream_and_queue() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_QUEUE_DIR.to_string(), nats_queue_dir());
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "on".to_string());
config.insert(NATS_JETSTREAM_STREAM_NAME.to_string(), "RUSTFS_EVENTS".to_string());
validate_nats_server_config(&nats_server(), &config, "").expect("a stream name and queue dir accept enabling jetstream");
}
#[test]
fn validate_nats_server_config_audit_parity_matches_notify() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_QUEUE_DIR.to_string(), nats_queue_dir());
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "on".to_string());
// The same invalid combination (enabled, stream name missing) is rejected identically on the
// notify and the audit path, proving one shared validator with no drift.
let notify = validate_nats_server_config(&nats_server(), &config, "/opt/rustfs/events").expect_err("notify rejects");
let audit = validate_nats_server_config(&nats_server(), &config, "/opt/rustfs/audit").expect_err("audit rejects");
assert_eq!(notify.to_string(), audit.to_string());
}
#[test]
fn validate_nats_server_config_accepts_jetstream_absent() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_QUEUE_DIR.to_string(), nats_queue_dir());
validate_nats_server_config(&nats_server(), &config, "").expect("baseline config validates");
}
#[test]
fn parse_jetstream_enable_accepts_the_standard_boolean_forms() {
// An absent or blank key is None, legitimately disabled.
assert_eq!(parse_jetstream_enable(&KVS::new()).unwrap(), None, "an absent key parses as unset");
let mut blank = KVS::new();
blank.insert(NATS_JETSTREAM_ENABLE.to_string(), " ".to_string());
assert_eq!(parse_jetstream_enable(&blank).unwrap(), None, "a blank value parses as unset");
for (value, expected) in [
("on", true),
("off", false),
("true", true),
("false", false),
("yes", true),
("no", false),
("1", true),
("0", false),
("enabled", true),
("disabled", false),
] {
let mut config = KVS::new();
config.insert(NATS_JETSTREAM_ENABLE.to_string(), value.to_string());
assert_eq!(
parse_jetstream_enable(&config).unwrap(),
Some(expected),
"value {value} parses as {expected}"
);
}
}
#[test]
fn parse_jetstream_enable_rejects_an_unparsable_value_naming_the_key() {
// A typo must fail validation rather than silently disabling the durability guarantee.
for value in ["y", "t", "enabl", "10"] {
let mut config = KVS::new();
config.insert(NATS_JETSTREAM_ENABLE.to_string(), value.to_string());
let err = parse_jetstream_enable(&config).expect_err("an unparsable value is rejected");
assert!(
err.to_string().contains(NATS_JETSTREAM_ENABLE),
"the error names the key for value {value}: {err}"
);
}
}
#[test]
fn validate_nats_server_config_rejects_an_invalid_jetstream_enable_value() {
let mut config = KVS::new();
config.insert(NATS_SUBJECT.to_string(), "events".to_string());
config.insert(NATS_QUEUE_DIR.to_string(), nats_queue_dir());
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "y".to_string());
let err = validate_nats_server_config(&nats_server(), &config, "")
.expect_err("an unparsable enable value fails validation instead of passing as disabled");
assert!(err.to_string().contains(NATS_JETSTREAM_ENABLE), "the error names the key: {err}");
}
#[test]
fn validate_pulsar_broker_config_rejects_tls_ca_without_tls_scheme() {
let mut config = KVS::new();
crates/targets/src/config/target_args.rs
+87 -16
View File
@@ -13,7 +13,8 @@
// limitations under the License.
use super::common::{
parse_target_bool, parse_url, validate_nats_server_config, validate_outbound_http_url, validate_pulsar_broker_config,
parse_jetstream_ack_timeout_secs, parse_jetstream_enable, parse_target_bool, parse_url, validate_nats_server_config,
validate_outbound_http_url, validate_pulsar_broker_config,
};
use crate::error::TargetError;
use crate::target::{
@@ -38,17 +39,17 @@ use rustfs_config::{
MQTT_KEEP_ALIVE_INTERVAL, MQTT_PASSWORD, MQTT_QOS, MQTT_QUEUE_DIR, MQTT_QUEUE_LIMIT, MQTT_RECONNECT_INTERVAL, MQTT_TLS_CA,
MQTT_TLS_CLIENT_CERT, MQTT_TLS_CLIENT_KEY, MQTT_TLS_POLICY, MQTT_TLS_TRUST_LEAF_AS_CA, MQTT_TOPIC, MQTT_USERNAME,
MQTT_WS_PATH_ALLOWLIST, MYSQL_DSN_STRING, MYSQL_FORMAT, MYSQL_MAX_OPEN_CONNECTIONS, MYSQL_QUEUE_DIR, MYSQL_QUEUE_LIMIT,
MYSQL_TABLE, MYSQL_TLS_CA, MYSQL_TLS_CLIENT_CERT, MYSQL_TLS_CLIENT_KEY, NATS_ADDRESS, NATS_CREDENTIALS_FILE, NATS_PASSWORD,
NATS_QUEUE_DIR, NATS_QUEUE_LIMIT, NATS_SUBJECT, NATS_TLS_CA, NATS_TLS_CLIENT_CERT, NATS_TLS_CLIENT_KEY, NATS_TLS_REQUIRED,
NATS_TOKEN, NATS_USERNAME, POSTGRES_DSN_STRING, POSTGRES_FORMAT, POSTGRES_QUEUE_DIR, POSTGRES_QUEUE_LIMIT, POSTGRES_TABLE,
POSTGRES_TLS_CA, POSTGRES_TLS_CLIENT_CERT, POSTGRES_TLS_CLIENT_KEY, POSTGRES_TLS_REQUIRED, PULSAR_AUTH_TOKEN, PULSAR_BROKER,
PULSAR_PASSWORD, PULSAR_QUEUE_DIR, PULSAR_QUEUE_LIMIT, PULSAR_TLS_ALLOW_INSECURE, PULSAR_TLS_CA,
PULSAR_TLS_HOSTNAME_VERIFICATION, PULSAR_TOPIC, PULSAR_USERNAME, REDIS_CHANNEL, REDIS_CONNECTION_TIMEOUT,
REDIS_KEEP_ALIVE_INTERVAL, REDIS_MAX_RETRY_ATTEMPTS, REDIS_MAX_RETRY_DELAY, REDIS_MIN_RETRY_DELAY, REDIS_PASSWORD,
REDIS_PIPELINE_BUFFER_SIZE, REDIS_QUEUE_DIR, REDIS_QUEUE_LIMIT, REDIS_RECONNECT_RETRY_ATTEMPTS, REDIS_RESPONSE_TIMEOUT,
REDIS_TLS_ALLOW_INSECURE, REDIS_TLS_CA, REDIS_TLS_CLIENT_CERT, REDIS_TLS_CLIENT_KEY, REDIS_TLS_POLICY, REDIS_URL,
REDIS_USERNAME, RUSTFS_WEBHOOK_SKIP_TLS_VERIFY_DEFAULT, WEBHOOK_AUTH_TOKEN, WEBHOOK_CLIENT_CA, WEBHOOK_CLIENT_CERT,
WEBHOOK_CLIENT_KEY, WEBHOOK_ENDPOINT, WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_LIMIT, WEBHOOK_SKIP_TLS_VERIFY,
MYSQL_TABLE, MYSQL_TLS_CA, MYSQL_TLS_CLIENT_CERT, MYSQL_TLS_CLIENT_KEY, NATS_ADDRESS, NATS_CREDENTIALS_FILE,
NATS_JETSTREAM_STREAM_NAME, NATS_PASSWORD, NATS_QUEUE_DIR, NATS_QUEUE_LIMIT, NATS_SUBJECT, NATS_TLS_CA, NATS_TLS_CLIENT_CERT,
NATS_TLS_CLIENT_KEY, NATS_TLS_REQUIRED, NATS_TOKEN, NATS_USERNAME, POSTGRES_DSN_STRING, POSTGRES_FORMAT, POSTGRES_QUEUE_DIR,
POSTGRES_QUEUE_LIMIT, POSTGRES_TABLE, POSTGRES_TLS_CA, POSTGRES_TLS_CLIENT_CERT, POSTGRES_TLS_CLIENT_KEY,
POSTGRES_TLS_REQUIRED, PULSAR_AUTH_TOKEN, PULSAR_BROKER, PULSAR_PASSWORD, PULSAR_QUEUE_DIR, PULSAR_QUEUE_LIMIT,
PULSAR_TLS_ALLOW_INSECURE, PULSAR_TLS_CA, PULSAR_TLS_HOSTNAME_VERIFICATION, PULSAR_TOPIC, PULSAR_USERNAME, REDIS_CHANNEL,
REDIS_CONNECTION_TIMEOUT, REDIS_KEEP_ALIVE_INTERVAL, REDIS_MAX_RETRY_ATTEMPTS, REDIS_MAX_RETRY_DELAY, REDIS_MIN_RETRY_DELAY,
REDIS_PASSWORD, REDIS_PIPELINE_BUFFER_SIZE, REDIS_QUEUE_DIR, REDIS_QUEUE_LIMIT, REDIS_RECONNECT_RETRY_ATTEMPTS,
REDIS_RESPONSE_TIMEOUT, REDIS_TLS_ALLOW_INSECURE, REDIS_TLS_CA, REDIS_TLS_CLIENT_CERT, REDIS_TLS_CLIENT_KEY,
REDIS_TLS_POLICY, REDIS_URL, REDIS_USERNAME, RUSTFS_WEBHOOK_SKIP_TLS_VERIFY_DEFAULT, WEBHOOK_AUTH_TOKEN, WEBHOOK_CLIENT_CA,
WEBHOOK_CLIENT_CERT, WEBHOOK_CLIENT_KEY, WEBHOOK_ENDPOINT, WEBHOOK_QUEUE_DIR, WEBHOOK_QUEUE_LIMIT, WEBHOOK_SKIP_TLS_VERIFY,
};
use std::path::Path;
use std::time::Duration;
@@ -315,6 +316,11 @@ pub fn build_nats_args(config: &KVS, default_queue_dir: &str, target_type: Targe
.lookup(NATS_QUEUE_LIMIT)
.and_then(|v| v.parse::<u64>().ok())
.unwrap_or(DEFAULT_LIMIT),
// Strict parse: an unparsable value is a configuration error, never a silent disable, so the
// durability guarantee the operator asked for cannot vanish over a typo.
jetstream_enable: parse_jetstream_enable(config)?,
jetstream_stream_name: config.lookup(NATS_JETSTREAM_STREAM_NAME).filter(|name| !name.is_empty()),
jetstream_ack_timeout_secs: parse_jetstream_ack_timeout_secs(config)?,
target_type,
})
}
@@ -598,9 +604,9 @@ pub fn validate_mysql_config(config: &KVS, default_queue_dir: &str) -> Result<()
#[cfg(test)]
mod tests {
use super::{
build_amqp_args, build_kafka_args, build_mysql_args, build_postgres_args, build_redis_args, build_webhook_args,
validate_amqp_config, validate_kafka_config, validate_mysql_config, validate_postgres_config, validate_redis_config,
validate_webhook_config,
build_amqp_args, build_kafka_args, build_mysql_args, build_nats_args, build_postgres_args, build_redis_args,
build_webhook_args, validate_amqp_config, validate_kafka_config, validate_mysql_config, validate_postgres_config,
validate_redis_config, validate_webhook_config,
};
use crate::target::{
TargetType,
@@ -612,7 +618,8 @@ mod tests {
AMQP_EXCHANGE, AMQP_MANDATORY, AMQP_PASSWORD, AMQP_PERSISTENT, AMQP_QUEUE_DIR, AMQP_ROUTING_KEY, AMQP_TLS_CLIENT_CERT,
AMQP_TLS_CLIENT_KEY, AMQP_URL, AMQP_USERNAME, KAFKA_ACKS, KAFKA_BROKERS, KAFKA_SASL_ENABLE, KAFKA_SASL_MECHANISM,
KAFKA_SASL_PASSWORD, KAFKA_SASL_USERNAME, KAFKA_TLS_ENABLE, KAFKA_TOPIC, MYSQL_DSN_STRING, MYSQL_MAX_OPEN_CONNECTIONS,
MYSQL_QUEUE_DIR, MYSQL_TABLE, MYSQL_TLS_CA, MYSQL_TLS_CLIENT_CERT, MYSQL_TLS_CLIENT_KEY, POSTGRES_DSN_STRING,
MYSQL_QUEUE_DIR, MYSQL_TABLE, MYSQL_TLS_CA, MYSQL_TLS_CLIENT_CERT, MYSQL_TLS_CLIENT_KEY, NATS_ADDRESS,
NATS_JETSTREAM_ACK_TIMEOUT_SECS, NATS_JETSTREAM_ENABLE, NATS_JETSTREAM_STREAM_NAME, NATS_SUBJECT, POSTGRES_DSN_STRING,
POSTGRES_FORMAT, POSTGRES_QUEUE_DIR, POSTGRES_TABLE, POSTGRES_TLS_CA, POSTGRES_TLS_CLIENT_CERT, POSTGRES_TLS_CLIENT_KEY,
REDIS_CHANNEL, REDIS_CONNECTION_TIMEOUT, REDIS_MAX_RETRY_DELAY, REDIS_MIN_RETRY_DELAY, REDIS_PIPELINE_BUFFER_SIZE,
REDIS_RECONNECT_RETRY_ATTEMPTS, REDIS_RESPONSE_TIMEOUT, REDIS_TLS_ALLOW_INSECURE, REDIS_URL, WEBHOOK_ENDPOINT,
@@ -1157,4 +1164,68 @@ mod tests {
let err = validate_postgres_config(&config, "").expect_err("relative tls_client_cert should fail");
assert!(err.to_string().contains("must be an absolute path"));
}
fn nats_base_config() -> KVS {
let mut config = KVS::new();
config.insert(NATS_ADDRESS.to_string(), "nats://127.0.0.1:4222".to_string());
config.insert(NATS_SUBJECT.to_string(), "rustfs.events".to_string());
config
}
// Absolute on Linux, macOS, and Windows. temp_dir needs no filesystem to exist for a
// validation-only test, and Path::is_absolute stays true across platforms.
fn nats_queue_dir() -> String {
std::env::temp_dir().join("rustfs-nats-queue").to_string_lossy().into_owned()
}
#[test]
fn build_nats_args_parses_jetstream_keys() {
let mut config = nats_base_config();
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "on".to_string());
config.insert(NATS_JETSTREAM_STREAM_NAME.to_string(), "RUSTFS_EVENTS".to_string());
config.insert(NATS_JETSTREAM_ACK_TIMEOUT_SECS.to_string(), "45".to_string());
for target_type in [TargetType::NotifyEvent, TargetType::AuditLog] {
let args = build_nats_args(&config, &nats_queue_dir(), target_type).expect("jetstream keys parse");
assert_eq!(args.jetstream_enable, Some(true));
assert_eq!(args.jetstream_stream_name.as_deref(), Some("RUSTFS_EVENTS"));
assert_eq!(args.jetstream_ack_timeout_secs, Some(45));
}
}
#[test]
fn build_nats_args_rejects_an_invalid_jetstream_enable_value() {
// A typo in the enable flag is a configuration error naming the key, never a silent
// disable that drops the durability guarantee the operator asked for.
let mut config = nats_base_config();
config.insert(NATS_JETSTREAM_ENABLE.to_string(), "t".to_string());
let err = build_nats_args(&config, &nats_queue_dir(), TargetType::NotifyEvent)
.expect_err("an unparsable enable value fails the build");
assert!(err.to_string().contains(NATS_JETSTREAM_ENABLE), "the error names the key: {err}");
}
#[test]
fn build_nats_args_without_jetstream_keys_is_flag_off() {
let config = nats_base_config();
let args = build_nats_args(&config, &nats_queue_dir(), TargetType::NotifyEvent).expect("baseline config parses");
assert_eq!(args.jetstream_enable, None);
assert_eq!(args.jetstream_stream_name, None);
assert_eq!(args.jetstream_ack_timeout_secs, None);
assert_eq!(args.address, "nats://127.0.0.1:4222");
assert_eq!(args.subject, "rustfs.events");
assert_eq!(args.queue_dir, nats_queue_dir());
args.validate().expect("flag-off config validates");
}
#[test]
fn build_nats_args_rejects_non_integer_ack_timeout() {
let mut config = nats_base_config();
config.insert(NATS_JETSTREAM_ACK_TIMEOUT_SECS.to_string(), "soon".to_string());
let err = build_nats_args(&config, &nats_queue_dir(), TargetType::NotifyEvent)
.expect_err("non-integer ack timeout should be rejected");
assert!(err.to_string().contains("whole number of seconds"));
}
}