#![allow(unused_imports)]
#![allow(unused_variables)]
use crate::bucket::metadata::BucketMetadata;
use crate::event::targetlist::TargetList;
use crate::object_api::ObjectInfo;
use crate::store::ECStore;
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::OnceLock;
use std::sync::atomic::Ordering;
use tokio::sync::RwLock;
use tracing::warn;
#[allow(
dead_code,
reason = "ecstore-side notification skeleton superseded by rustfs-notify; see module note (backlog#1823)"
)]
pub struct EventNotifier {
target_list: TargetList,
}
#[allow(
dead_code,
reason = "ecstore-side notification skeleton superseded by rustfs-notify; see module note (backlog#1823)"
)]
impl EventNotifier {
pub fn new() -> Arc<RwLock<Self>> {
Arc::new(RwLock::new(Self {
target_list: TargetList::new(),
}))
}
fn get_arn_list(&self) -> Vec<String> {
warn!(
event_count = self.target_list.total_events.load(Ordering::Relaxed),
"event notifier arn list requested but not implemented in this build"
);
Vec::new()
}
fn set(&self, bucket: &str, meta: BucketMetadata) {
warn!(bucket = bucket, "event notifier set() called but currently no-op in this build");
}
fn init_bucket_targets(&self, _api: ECStore) -> Result<(), std::io::Error> {
warn!("init_bucket_targets called but currently no-op in this build");
Ok(())
}
fn send(&self, args: EventArgs) {
warn!(
event_name = args.event_name,
bucket = args.bucket_name,
"event send() called but notifier is not fully implemented in this build"
);
}
}
#[derive(Debug, Default)]
pub struct EventArgs {
pub event_name: String,
pub bucket_name: String,
pub object: ObjectInfo,
pub req_params: HashMap<String, String>,
pub resp_elements: HashMap<String, String>,
pub host: String,
pub user_agent: String,
}
impl EventArgs {}
type EventDispatchHook = Arc<dyn Fn(EventArgs) + Send + Sync + 'static>;
static EVENT_DISPATCH_HOOK: OnceLock<EventDispatchHook> = OnceLock::new();
pub fn register_event_dispatch_hook<F>(hook: F) -> bool
where
F: Fn(EventArgs) + Send + Sync + 'static,
{
EVENT_DISPATCH_HOOK.set(Arc::new(hook)).is_ok()
}
pub fn send_event(args: EventArgs) {
if let Some(hook) = EVENT_DISPATCH_HOOK.get() {
hook(args);
return;
}
warn!(
event_name = args.event_name,
bucket = args.bucket_name,
"event send() dropped because no event dispatch hook is registered"
);
}
#[cfg(test)]
pub(crate) mod test_recorder {
use super::register_event_dispatch_hook;
use std::sync::{Mutex, OnceLock};
use uuid::Uuid;
#[derive(Clone, Debug)]
pub(crate) struct RecordedEvent {
pub(crate) event_name: String,
pub(crate) bucket: String,
pub(crate) object: String,
pub(crate) version_id: Option<Uuid>,
pub(crate) delete_marker: bool,
}
static RECORDED: OnceLock<Mutex<Vec<RecordedEvent>>> = OnceLock::new();
fn recorded() -> &'static Mutex<Vec<RecordedEvent>> {
RECORDED.get_or_init(|| Mutex::new(Vec::new()))
}
pub(crate) fn install() {
static INSTALLED: OnceLock<()> = OnceLock::new();
INSTALLED.get_or_init(|| {
assert!(
register_event_dispatch_hook(|args| {
recorded().lock().unwrap_or_else(|err| err.into_inner()).push(RecordedEvent {
event_name: args.event_name,
bucket: args.bucket_name,
object: args.object.name,
version_id: args.object.version_id,
delete_marker: args.object.delete_marker,
});
}),
"the test event recorder must own this binary's dispatch hook"
);
});
}
pub(crate) fn recorded_for_bucket(bucket: &str) -> Vec<RecordedEvent> {
recorded()
.lock()
.unwrap_or_else(|err| err.into_inner())
.iter()
.filter(|event| event.bucket == bucket)
.cloned()
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn send_event_dispatches_to_registered_hook() {
test_recorder::install();
let bucket = format!("event-dispatch-{}", uuid::Uuid::new_v4().simple());
send_event(EventArgs {
event_name: "s3:ObjectCreated:Put".to_string(),
bucket_name: bucket.clone(),
..Default::default()
});
let dispatched = test_recorder::recorded_for_bucket(&bucket);
assert_eq!(dispatched.len(), 1);
assert_eq!(dispatched[0].event_name, "s3:ObjectCreated:Put");
}
}