1use 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
23const LEGACY_AMZ_META_INTERNAL_PREFIX: &str = "x-amz-meta-internal-";
25
26fn 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#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(rename_all = "camelCase")]
42pub struct Identity {
43 pub principal_id: String,
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(rename_all = "camelCase")]
50pub struct Bucket {
51 pub name: String,
53 pub owner_identity: Identity,
55 pub arn: String,
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize, Default)]
61#[serde(rename_all = "camelCase")]
62pub struct Object {
63 pub key: String,
65 #[serde(skip_serializing_if = "Option::is_none")]
67 pub size: Option<i64>,
68 #[serde(skip_serializing_if = "Option::is_none")]
70 pub e_tag: Option<String>,
71 #[serde(skip_serializing_if = "Option::is_none")]
73 pub content_type: Option<String>,
74 #[serde(skip_serializing_if = "Option::is_none")]
76 pub user_metadata: Option<HashMap<String, String>>,
77 #[serde(skip_serializing_if = "Option::is_none")]
79 pub version_id: Option<String>,
80 pub sequencer: String,
82}
83
84#[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#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(rename_all = "camelCase")]
103pub struct Metadata {
104 #[serde(rename = "s3SchemaVersion")]
106 pub schema_version: String,
107 pub configuration_id: String,
109 pub bucket: Bucket,
111 pub object: Object,
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(rename_all = "camelCase")]
118pub struct Source {
119 pub host: String,
121 pub port: String,
123 pub user_agent: String,
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(rename_all = "camelCase")]
130pub struct GlacierEventData {
131 pub restore_event_data: RestoreEventData,
132}
133
134#[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#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(rename_all = "camelCase")]
145pub struct Event {
146 pub event_version: String,
148 pub event_source: String,
150 pub aws_region: String,
152 #[serde(
154 serialize_with = "serialize_event_time_millis",
155 deserialize_with = "deserialize_event_time_millis"
156 )]
157 pub event_time: Timestamp,
158 pub event_name: EventName,
160 pub user_identity: Identity,
162 pub request_parameters: HashMap<String, String>,
164 pub response_elements: HashMap<String, String>,
166 pub s3: Metadata,
168 #[serde(skip_serializing_if = "Option::is_none")]
170 pub glacier_event_data: Option<GlacierEventData>,
171 pub source: Source,
173}
174
175impl Event {
176 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 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 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 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(), 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 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 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#[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 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 pub fn event_name(mut self, event_name: EventName) -> Self {
468 self.event_name = event_name;
469 self
470 }
471
472 pub fn bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
474 self.bucket_name = bucket_name.into();
475 self
476 }
477
478 pub fn object(mut self, object: impl Into<NotifyObjectInfo>) -> Self {
480 self.object = object.into();
481 self
482 }
483
484 pub fn req_params(mut self, req_params: HashMap<String, String>) -> Self {
486 self.req_params = req_params;
487 self
488 }
489
490 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 pub fn resp_elements(mut self, resp_elements: HashMap<String, String>) -> Self {
498 self.resp_elements = resp_elements;
499 self
500 }
501
502 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 pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
510 self.version_id = version_id.into();
511 self
512 }
513
514 pub fn host(mut self, host: impl Into<String>) -> Self {
516 self.host = host.into();
517 self
518 }
519
520 pub fn port(mut self, port: u16) -> Self {
522 self.port = port;
523 self
524 }
525
526 pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
528 self.user_agent = user_agent.into();
529 self
530 }
531
532 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 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 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 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 user_defined.insert("x-amz-meta-internal-foo".to_string(), "bar".to_string());
638 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 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 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 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 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}