Skip to main content

rustfs_notify/
event.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use hashbrown::HashMap;
16use jiff::{Timestamp, tz::TimeZone};
17use rustfs_s3_ops::is_object_removed_event;
18use rustfs_s3_types::{EventName, event_schema_version};
19use rustfs_utils::http::{is_encryption_metadata_key, is_internal_key};
20use serde::{Deserialize, Serialize};
21use url::form_urlencoded;
22
23/// Legacy internal-metadata prefix retained for backward compatibility.
24const LEGACY_AMZ_META_INTERNAL_PREFIX: &str = "x-amz-meta-internal-";
25
26/// Returns `true` if `key` is RustFS/MinIO internal metadata that must not be exposed in
27/// notification `userMetadata`. Covers the internal xl.meta prefixes
28/// (`x-rustfs-internal-*` / `x-minio-internal-*`), the server-side-encryption prefixes
29/// (`x-rustfs-encryption-*` / `x-minio-encryption-*`), and the legacy
30/// `x-amz-meta-internal-*` prefix. Case-insensitive.
31fn is_internal_metadata_key(key: &str) -> bool {
32    is_internal_key(key)
33        || is_encryption_metadata_key(key)
34        || key.len() >= LEGACY_AMZ_META_INTERNAL_PREFIX.len()
35            && key.as_bytes()[..LEGACY_AMZ_META_INTERNAL_PREFIX.len()]
36                .eq_ignore_ascii_case(LEGACY_AMZ_META_INTERNAL_PREFIX.as_bytes())
37}
38
39/// Represents the identity of the user who triggered the event
40#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(rename_all = "camelCase")]
42pub struct Identity {
43    /// The principal ID of the user
44    pub principal_id: String,
45}
46
47/// Represents the bucket that the object is in
48#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(rename_all = "camelCase")]
50pub struct Bucket {
51    /// The name of the bucket
52    pub name: String,
53    /// The owner identity of the bucket
54    pub owner_identity: Identity,
55    /// The Amazon Resource Name (ARN) of the bucket
56    pub arn: String,
57}
58
59/// Represents the object that the event occurred on
60#[derive(Debug, Clone, Serialize, Deserialize, Default)]
61#[serde(rename_all = "camelCase")]
62pub struct Object {
63    /// The key (name) of the object
64    pub key: String,
65    /// The size of the object in bytes
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub size: Option<i64>,
68    /// The entity tag (ETag) of the object
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub e_tag: Option<String>,
71    /// The content type of the object
72    #[serde(skip_serializing_if = "Option::is_none")]
73    pub content_type: Option<String>,
74    /// User-defined metadata associated with the object
75    #[serde(skip_serializing_if = "Option::is_none")]
76    pub user_metadata: Option<HashMap<String, String>>,
77    /// The version ID of the object (if versioning is enabled)
78    #[serde(skip_serializing_if = "Option::is_none")]
79    pub version_id: Option<String>,
80    /// A unique identifier for the event
81    pub sequencer: String,
82}
83
84/// Object metadata required by notification event serialization.
85#[derive(Debug, Clone, Default)]
86pub struct NotifyObjectInfo {
87    pub bucket: String,
88    pub name: String,
89    pub size: i64,
90    pub etag: Option<String>,
91    pub content_type: Option<String>,
92    pub user_defined: HashMap<String, String>,
93    pub version_id: Option<String>,
94    pub mod_time: Option<Timestamp>,
95    pub restore_expires: Option<Timestamp>,
96    pub storage_class: Option<String>,
97    pub transitioned_tier: Option<String>,
98}
99
100/// Metadata about the event
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(rename_all = "camelCase")]
103pub struct Metadata {
104    /// The schema version of the event
105    #[serde(rename = "s3SchemaVersion")]
106    pub schema_version: String,
107    /// The ID of the configuration that triggered the event
108    pub configuration_id: String,
109    /// Information about the bucket
110    pub bucket: Bucket,
111    /// Information about the object
112    pub object: Object,
113}
114
115/// Information about the source of the event
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(rename_all = "camelCase")]
118pub struct Source {
119    /// The host where the event originated
120    pub host: String,
121    /// The port on the host
122    pub port: String,
123    /// The user agent that caused the event
124    pub user_agent: String,
125}
126
127/// Additional data included for restore-completed events.
128#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(rename_all = "camelCase")]
130pub struct GlacierEventData {
131    pub restore_event_data: RestoreEventData,
132}
133
134/// Restore-specific event attributes for `s3:ObjectRestore:Completed`.
135#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(rename_all = "camelCase")]
137pub struct RestoreEventData {
138    pub lifecycle_restoration_expiry_time: String,
139    pub lifecycle_restore_storage_class: String,
140}
141
142/// Represents a storage event
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(rename_all = "camelCase")]
145pub struct Event {
146    /// The version of the event
147    pub event_version: String,
148    /// The source of the event
149    pub event_source: String,
150    /// The AWS region where the event occurred
151    pub aws_region: String,
152    /// The time when the event occurred
153    #[serde(
154        serialize_with = "serialize_event_time_millis",
155        deserialize_with = "deserialize_event_time_millis"
156    )]
157    pub event_time: Timestamp,
158    /// The name of the event
159    pub event_name: EventName,
160    /// The identity of the user who triggered the event
161    pub user_identity: Identity,
162    /// Parameters from the request that caused the event
163    pub request_parameters: HashMap<String, String>,
164    /// Elements from the response
165    pub response_elements: HashMap<String, String>,
166    /// Metadata about the event
167    pub s3: Metadata,
168    /// Additional restore event data when present.
169    #[serde(skip_serializing_if = "Option::is_none")]
170    pub glacier_event_data: Option<GlacierEventData>,
171    /// Information about the source of the event
172    pub source: Source,
173}
174
175impl Event {
176    /// Creates a test event for a given bucket and object
177    pub fn new_test_event(bucket: &str, key: &str, event_name: EventName) -> Self {
178        let mut user_metadata = HashMap::new();
179        user_metadata.insert("x-amz-meta-test".to_string(), "value".to_string());
180        user_metadata.insert("x-amz-storage-storage-options".to_string(), "value".to_string());
181        user_metadata.insert("x-amz-meta-".to_string(), "value".to_string());
182        user_metadata.insert("x-rustfs-meta-".to_string(), "rustfs-value".to_string());
183        user_metadata.insert("x-request-id".to_string(), "request-id-123".to_string());
184        user_metadata.insert("x-bucket".to_string(), "bucket".to_string());
185        user_metadata.insert("x-object".to_string(), "object".to_string());
186        user_metadata.insert("x-rustfs-origin-endpoint".to_string(), "http://127.0.0.1".to_string());
187        user_metadata.insert("x-rustfs-user-metadata".to_string(), "metadata".to_string());
188        user_metadata.insert("x-rustfs-deployment-id".to_string(), "deployment-id-123".to_string());
189        user_metadata.insert("x-rustfs-origin-endpoint-code".to_string(), "http://127.0.0.1".to_string());
190        user_metadata.insert("x-rustfs-bucket-name".to_string(), "bucket".to_string());
191        user_metadata.insert("x-rustfs-object-key".to_string(), key.to_string());
192        user_metadata.insert("x-rustfs-object-size".to_string(), "1024".to_string());
193        user_metadata.insert("x-rustfs-object-etag".to_string(), "etag123".to_string());
194        user_metadata.insert("x-rustfs-object-version-id".to_string(), "1".to_string());
195        user_metadata.insert("x-request-time".to_string(), format_timestamp_rfc3339_millis(&Timestamp::now()));
196
197        Event {
198            event_version: event_schema_version(event_name).to_string(),
199            event_source: "rustfs:s3".to_string(),
200            aws_region: "us-east-1".to_string(),
201            event_time: Timestamp::now(),
202            event_name,
203            user_identity: Identity {
204                principal_id: "rustfs".to_string(),
205            },
206            request_parameters: HashMap::new(),
207            response_elements: HashMap::new(),
208            s3: Metadata {
209                schema_version: "1.0".to_string(),
210                configuration_id: "test-config".to_string(),
211                bucket: Bucket {
212                    name: bucket.to_string(),
213                    owner_identity: Identity {
214                        principal_id: "rustfs".to_string(),
215                    },
216                    arn: format!("arn:rustfs:s3:::{bucket}"),
217                },
218                object: Object {
219                    key: key.to_string(),
220                    size: Some(1024),
221                    e_tag: Some("etag123".to_string()),
222                    content_type: Some("application/octet-stream".to_string()),
223                    user_metadata: Some(user_metadata),
224                    version_id: Some("1".to_string()),
225                    sequencer: "0055AED6DCD90281E5".to_string(),
226                },
227            },
228            glacier_event_data: None,
229            source: Source {
230                host: "127.0.0.1".to_string(),
231                port: "9000".to_string(),
232                user_agent: "RustFS (linux; amd64) rustfs-rs/0.1".to_string(),
233            },
234        }
235    }
236    /// Return event mask
237    pub fn mask(&self) -> u64 {
238        self.event_name.mask()
239    }
240
241    pub fn new(args: EventArgs) -> Self {
242        let event_time = Timestamp::now();
243        let sequencer = match args.object.mod_time {
244            Some(t) => sequencer_from_timestamp(t),
245            None => sequencer_from_timestamp(event_time),
246        };
247
248        let mut resp_elements = args.resp_elements.clone();
249        initialize_response_elements(&mut resp_elements, &["x-amz-request-id", "x-amz-id-2"]);
250
251        // URL encoding of object keys
252        let key_name = form_urlencoded::byte_serialize(args.object.name.as_bytes()).collect::<String>();
253        let principal_id = args.req_params.get("principalId").unwrap_or(&String::new()).to_string();
254
255        // An unversioned object must omit `versionId` entirely rather than emit it as
256        // an empty string. Prefer the object's own version id, fall back to the
257        // request-scoped one, and treat an empty value from either source as "no
258        // version" so serialization skips the field (`skip_serializing_if` on
259        // `Object::version_id`). This matches S3 and the repo's tier convention that a
260        // `None`/`""` version means "unversioned" (backlog#984).
261        let version_id = args
262            .object
263            .version_id
264            .clone()
265            .filter(|v| !v.is_empty())
266            .or_else(|| Some(args.version_id.clone()))
267            .filter(|v| !v.is_empty());
268
269        let mut s3_metadata = Metadata {
270            schema_version: "1.0".to_string(),
271            configuration_id: "Config".to_string(), // or from args
272            bucket: Bucket {
273                name: args.bucket_name.clone(),
274                owner_identity: Identity {
275                    principal_id: principal_id.clone(),
276                },
277                arn: format!("arn:aws:s3:::{}", args.bucket_name),
278            },
279            object: Object {
280                key: key_name,
281                version_id,
282                sequencer,
283                ..Default::default()
284            },
285        };
286
287        let is_removed_event = is_object_removed_event(args.event_name);
288
289        if !is_removed_event {
290            s3_metadata.object.size = Some(args.object.size);
291            s3_metadata.object.e_tag = args.object.etag.clone();
292            s3_metadata.object.content_type = args.object.content_type.clone();
293            // Filter out internal/reserved metadata so it never leaks to downstream
294            // notification targets (webhook/MQ). RustFS stores internal metadata under both
295            // `x-rustfs-internal-*` and `x-minio-internal-*` (see rustfs_utils metadata_compat),
296            // and server-side-encryption details under `x-rustfs-encryption-*` /
297            // `x-minio-encryption-*` (header_compat). All of these must be stripped; only genuine
298            // user-defined metadata (e.g. `x-amz-meta-*`) is preserved.
299            let mut user_metadata = HashMap::new();
300            for (k, v) in args.object.user_defined.iter() {
301                if is_internal_metadata_key(k) {
302                    continue;
303                }
304                user_metadata.insert(k.clone(), v.clone());
305            }
306            s3_metadata.object.user_metadata = Some(user_metadata);
307        }
308
309        let glacier_event_data = if args.event_name == EventName::ObjectRestoreCompleted {
310            args.object.restore_expires.and_then(|expiry_time| {
311                let storage_class = args
312                    .object
313                    .storage_class
314                    .clone()
315                    .or_else(|| args.object.transitioned_tier.clone())?;
316                Some(GlacierEventData {
317                    restore_event_data: RestoreEventData {
318                        lifecycle_restoration_expiry_time: format_timestamp_rfc3339_millis(&expiry_time),
319                        lifecycle_restore_storage_class: storage_class,
320                    },
321                })
322            })
323        } else {
324            None
325        };
326
327        Self {
328            event_version: event_schema_version(args.event_name).to_string(),
329            event_source: "rustfs:s3".to_string(),
330            aws_region: args.req_params.get("region").cloned().unwrap_or_default(),
331            event_time,
332            event_name: args.event_name,
333            user_identity: Identity { principal_id },
334            request_parameters: args.req_params,
335            response_elements: resp_elements,
336            s3: s3_metadata,
337            glacier_event_data,
338            source: Source {
339                host: args.host,
340                port: if args.port == 0 {
341                    "".to_string()
342                } else {
343                    args.port.to_string()
344                },
345                user_agent: args.user_agent,
346            },
347        }
348    }
349}
350
351fn serialize_event_time_millis<S>(value: &Timestamp, serializer: S) -> Result<S::Ok, S::Error>
352where
353    S: serde::Serializer,
354{
355    serializer.serialize_str(&format_timestamp_rfc3339_millis(value))
356}
357
358fn deserialize_event_time_millis<'de, D>(deserializer: D) -> Result<Timestamp, D::Error>
359where
360    D: serde::Deserializer<'de>,
361{
362    let value = String::deserialize(deserializer)?;
363    value.parse::<Timestamp>().map_err(serde::de::Error::custom)
364}
365
366fn format_timestamp_rfc3339_millis(value: &Timestamp) -> String {
367    let utc = value.to_zoned(TimeZone::UTC);
368    format!(
369        "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}Z",
370        utc.year(),
371        utc.month(),
372        utc.day(),
373        utc.hour(),
374        utc.minute(),
375        utc.second(),
376        utc.millisecond()
377    )
378}
379
380fn sequencer_from_timestamp(value: Timestamp) -> String {
381    match i64::try_from(value.as_nanosecond()) {
382        Ok(nanosecond) => format!("{nanosecond:X}"),
383        Err(_) => "0".to_string(),
384    }
385}
386
387fn initialize_response_elements(elements: &mut HashMap<String, String>, keys: &[&str]) {
388    for key in keys {
389        elements.entry(key.to_string()).or_default();
390    }
391}
392
393#[derive(Debug, Clone)]
394pub struct EventArgs {
395    pub event_name: EventName,
396    pub bucket_name: String,
397    pub object: NotifyObjectInfo,
398    pub req_params: HashMap<String, String>,
399    pub resp_elements: HashMap<String, String>,
400    pub version_id: String,
401    pub host: String,
402    pub port: u16,
403    pub user_agent: String,
404}
405
406impl EventArgs {
407    /// True when the RustFS replication header is explicitly enabled (`true` or `1`).
408    ///
409    /// Only `x-rustfs-source-replication-request` is considered here. Many clients (including the
410    /// console) send `x-minio-source-replication-request` for MinIO compatibility; treating that
411    /// as replication would suppress webhooks on normal browser deletes. Storage still honors both
412    /// prefixes when parsing the typed HTTP headers for `ObjectOptions`.
413    pub fn is_replication_request(&self) -> bool {
414        self.replication_header_value_true("x-rustfs-source-replication-request")
415    }
416
417    fn replication_header_value_true(&self, key: &str) -> bool {
418        self.req_params
419            .get(key)
420            .map(|v| v.eq_ignore_ascii_case("true") || v == "1")
421            .unwrap_or(false)
422    }
423}
424
425/// Builder for [`EventArgs`].
426///
427/// This builder provides a fluent API to construct an `EventArgs` instance,
428/// ensuring that all required fields are provided.
429///
430/// # Example
431///
432/// ```ignore
433/// let args = EventArgsBuilder::new(
434///     EventName::ObjectCreatedPut,
435///     "my-bucket",
436///     object_info,
437/// )
438/// .host("localhost:9000")
439/// .user_agent("my-app/1.0")
440/// .build();
441/// ```
442#[derive(Debug, Clone, Default)]
443pub struct EventArgsBuilder {
444    event_name: EventName,
445    bucket_name: String,
446    object: NotifyObjectInfo,
447    req_params: HashMap<String, String>,
448    resp_elements: HashMap<String, String>,
449    version_id: String,
450    host: String,
451    port: u16,
452    user_agent: String,
453}
454
455impl EventArgsBuilder {
456    /// Creates a new builder with the required fields.
457    pub fn new(event_name: EventName, bucket_name: impl Into<String>, object: impl Into<NotifyObjectInfo>) -> Self {
458        Self {
459            event_name,
460            bucket_name: bucket_name.into(),
461            object: object.into(),
462            ..Default::default()
463        }
464    }
465
466    /// Sets the event name.
467    pub fn event_name(mut self, event_name: EventName) -> Self {
468        self.event_name = event_name;
469        self
470    }
471
472    /// Sets the bucket name.
473    pub fn bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
474        self.bucket_name = bucket_name.into();
475        self
476    }
477
478    /// Sets the object information.
479    pub fn object(mut self, object: impl Into<NotifyObjectInfo>) -> Self {
480        self.object = object.into();
481        self
482    }
483
484    /// Sets the request parameters.
485    pub fn req_params(mut self, req_params: HashMap<String, String>) -> Self {
486        self.req_params = req_params;
487        self
488    }
489
490    /// Adds a single request parameter.
491    pub fn req_param(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
492        self.req_params.insert(key.into(), value.into());
493        self
494    }
495
496    /// Sets the response elements.
497    pub fn resp_elements(mut self, resp_elements: HashMap<String, String>) -> Self {
498        self.resp_elements = resp_elements;
499        self
500    }
501
502    /// Adds a single response element.
503    pub fn resp_element(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
504        self.resp_elements.insert(key.into(), value.into());
505        self
506    }
507
508    /// Sets the version ID.
509    pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
510        self.version_id = version_id.into();
511        self
512    }
513
514    /// Sets the host.
515    pub fn host(mut self, host: impl Into<String>) -> Self {
516        self.host = host.into();
517        self
518    }
519
520    /// Sets the port.
521    pub fn port(mut self, port: u16) -> Self {
522        self.port = port;
523        self
524    }
525
526    /// Sets the user agent.
527    pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
528        self.user_agent = user_agent.into();
529        self
530    }
531
532    /// Builds the final `EventArgs` instance.
533    ///
534    /// This method consumes the builder and returns the constructed `EventArgs`.
535    pub fn build(self) -> EventArgs {
536        EventArgs {
537            event_name: self.event_name,
538            bucket_name: self.bucket_name,
539            object: self.object,
540            req_params: self.req_params,
541            resp_elements: self.resp_elements,
542            version_id: self.version_id,
543            host: self.host,
544            port: self.port,
545            user_agent: self.user_agent,
546        }
547    }
548}
549
550#[cfg(test)]
551mod tests {
552    use super::*;
553
554    #[test]
555    fn new_test_event_uses_aws_compatible_event_versions() {
556        let acl_event = Event::new_test_event("bucket", "key", EventName::ObjectAclPut);
557        assert_eq!(acl_event.event_version, "2.3");
558
559        let tagging_event = Event::new_test_event("bucket", "key", EventName::ObjectTaggingPut);
560        assert_eq!(tagging_event.event_version, "2.3");
561
562        let lifecycle_event = Event::new_test_event("bucket", "key", EventName::LifecycleExpirationDelete);
563        assert_eq!(lifecycle_event.event_version, "2.3");
564
565        let put_event = Event::new_test_event("bucket", "key", EventName::ObjectCreatedPut);
566        assert_eq!(put_event.event_version, "2.1");
567    }
568
569    #[test]
570    fn event_new_uses_aws_compatible_event_versions() {
571        let args = EventArgsBuilder::new(
572            EventName::LifecycleTransition,
573            "bucket",
574            NotifyObjectInfo {
575                bucket: "bucket".to_string(),
576                name: "key".to_string(),
577                ..Default::default()
578            },
579        )
580        .build();
581        let event = Event::new(args);
582        assert_eq!(event.event_version, "2.3");
583    }
584
585    #[test]
586    fn event_new_preserves_legacy_sequencer_overflow_fallback() {
587        let args = EventArgsBuilder::new(
588            EventName::ObjectCreatedPut,
589            "bucket",
590            NotifyObjectInfo {
591                bucket: "bucket".to_string(),
592                name: "key".to_string(),
593                mod_time: Some(Timestamp::new(10_000_000_000, 0).expect("timestamp should be valid")),
594                ..Default::default()
595            },
596        )
597        .build();
598        let event = Event::new(args);
599        assert_eq!(event.s3.object.sequencer, "0");
600    }
601
602    #[test]
603    fn object_restore_completed_includes_glacier_event_data() {
604        let args = EventArgsBuilder::new(
605            EventName::ObjectRestoreCompleted,
606            "bucket",
607            NotifyObjectInfo {
608                bucket: "bucket".to_string(),
609                name: "key".to_string(),
610                restore_expires: Timestamp::new(1_700_000_000, 0).ok(),
611                storage_class: Some("GLACIER".to_string()),
612                ..Default::default()
613            },
614        )
615        .build();
616        let event = Event::new(args);
617
618        assert_eq!(event.event_version, "2.3");
619        let glacier = event.glacier_event_data.expect("glacier event data should be present");
620        assert_eq!(glacier.restore_event_data.lifecycle_restoration_expiry_time, "2023-11-14T22:13:20.000Z");
621        assert_eq!(glacier.restore_event_data.lifecycle_restore_storage_class, "GLACIER");
622    }
623
624    #[test]
625    fn event_user_metadata_strips_internal_and_encryption_keys() {
626        let mut user_defined = HashMap::new();
627        // RustFS internal (xl.meta) keys
628        user_defined.insert("x-rustfs-internal-inline-data".to_string(), "true".to_string());
629        user_defined.insert("x-rustfs-internal-transition-tier".to_string(), "WARM".to_string());
630        // MinIO internal keys (interop) + SSE internal metadata
631        user_defined.insert("x-minio-internal-compression".to_string(), "s2".to_string());
632        user_defined.insert("x-minio-internal-server-side-encryption-iv".to_string(), "secret-iv".to_string());
633        // Encryption prefixes (both flavors), including mixed-case
634        user_defined.insert("x-rustfs-encryption-key".to_string(), "wrapped-key".to_string());
635        user_defined.insert("X-Minio-Encryption-Iv".to_string(), "secret".to_string());
636        // Legacy internal prefix
637        user_defined.insert("x-amz-meta-internal-foo".to_string(), "bar".to_string());
638        // Genuine user metadata that MUST be preserved
639        user_defined.insert("x-amz-meta-project".to_string(), "rustfs".to_string());
640        user_defined.insert("content-type".to_string(), "text/plain".to_string());
641
642        let args = EventArgsBuilder::new(
643            EventName::ObjectCreatedPut,
644            "bucket",
645            NotifyObjectInfo {
646                bucket: "bucket".to_string(),
647                name: "key".to_string(),
648                user_defined,
649                ..Default::default()
650            },
651        )
652        .build();
653        let event = Event::new(args);
654
655        let user_metadata = event
656            .s3
657            .object
658            .user_metadata
659            .expect("user_metadata should be present for a create event");
660
661        // All internal / encryption keys stripped.
662        for internal in [
663            "x-rustfs-internal-inline-data",
664            "x-rustfs-internal-transition-tier",
665            "x-minio-internal-compression",
666            "x-minio-internal-server-side-encryption-iv",
667            "x-rustfs-encryption-key",
668            "X-Minio-Encryption-Iv",
669            "x-amz-meta-internal-foo",
670        ] {
671            assert!(
672                !user_metadata.contains_key(internal),
673                "internal key {internal:?} leaked into notification userMetadata"
674            );
675        }
676
677        // Genuine user metadata preserved unchanged.
678        assert_eq!(user_metadata.get("x-amz-meta-project").map(String::as_str), Some("rustfs"));
679        assert_eq!(user_metadata.get("content-type").map(String::as_str), Some("text/plain"));
680        assert_eq!(user_metadata.len(), 2);
681    }
682
683    #[test]
684    fn unversioned_object_omits_version_id() {
685        // Neither the object nor the request carries a version id: the field must be
686        // `None` so it is omitted from the serialized event, not `Some("")` (backlog#984).
687        let args = EventArgsBuilder::new(
688            EventName::ObjectCreatedPut,
689            "bucket",
690            NotifyObjectInfo {
691                bucket: "bucket".to_string(),
692                name: "key".to_string(),
693                version_id: None,
694                ..Default::default()
695            },
696        )
697        .version_id(String::new())
698        .build();
699        let event = Event::new(args);
700        assert_eq!(event.s3.object.version_id, None);
701
702        let json = serde_json::to_value(&event).expect("event should serialize");
703        assert!(
704            json.pointer("/s3/object/versionId").is_none(),
705            "unversioned object must not serialize a versionId field"
706        );
707    }
708
709    #[test]
710    fn empty_object_version_falls_back_then_omits() {
711        // Empty object version must not shadow a real request-scoped version.
712        let args = EventArgsBuilder::new(
713            EventName::ObjectCreatedPut,
714            "bucket",
715            NotifyObjectInfo {
716                bucket: "bucket".to_string(),
717                name: "key".to_string(),
718                version_id: Some(String::new()),
719                ..Default::default()
720            },
721        )
722        .version_id("v-42".to_string())
723        .build();
724        let event = Event::new(args);
725        assert_eq!(event.s3.object.version_id.as_deref(), Some("v-42"));
726    }
727
728    #[test]
729    fn present_object_version_is_preserved() {
730        let args = EventArgsBuilder::new(
731            EventName::ObjectCreatedPut,
732            "bucket",
733            NotifyObjectInfo {
734                bucket: "bucket".to_string(),
735                name: "key".to_string(),
736                version_id: Some("v-1".to_string()),
737                ..Default::default()
738            },
739        )
740        .build();
741        let event = Event::new(args);
742        assert_eq!(event.s3.object.version_id.as_deref(), Some("v-1"));
743    }
744
745    #[test]
746    fn event_time_serializes_with_millisecond_precision() {
747        let mut event = Event::new_test_event("bucket", "key", EventName::ObjectCreatedPut);
748        event.event_time = Timestamp::new(1_711_423_698, 870_816_000).expect("timestamp should be valid");
749
750        let json = serde_json::to_value(&event).expect("event should serialize");
751        assert_eq!(json.get("eventTime").and_then(|value| value.as_str()), Some("2024-03-26T03:28:18.870Z"));
752    }
753}
754
755#[cfg(test)]
756mod event_args_tests {
757    use super::{EventArgs, NotifyObjectInfo as ObjectInfo};
758    use hashbrown::HashMap;
759    use rustfs_s3_types::EventName;
760
761    fn args_with_headers(pairs: &[(&str, &str)]) -> EventArgs {
762        let mut req_params = HashMap::new();
763        for (k, v) in pairs {
764            req_params.insert((*k).to_string(), (*v).to_string());
765        }
766        EventArgs {
767            event_name: EventName::ObjectRemovedDelete,
768            bucket_name: "b".to_string(),
769            object: ObjectInfo::default(),
770            req_params,
771            resp_elements: HashMap::new(),
772            version_id: String::new(),
773            host: String::new(),
774            port: 0,
775            user_agent: String::new(),
776        }
777    }
778
779    #[test]
780    fn replication_request_requires_true_value() {
781        assert!(!args_with_headers(&[("x-rustfs-source-replication-request", "")]).is_replication_request());
782        assert!(!args_with_headers(&[("x-rustfs-source-replication-request", "false")]).is_replication_request());
783        assert!(args_with_headers(&[("x-rustfs-source-replication-request", "true")]).is_replication_request());
784        assert!(args_with_headers(&[("x-rustfs-source-replication-request", "True")]).is_replication_request());
785        assert!(!args_with_headers(&[("x-minio-source-replication-request", "true")]).is_replication_request());
786    }
787}