1use super::*;
16use crate::core::pools::{DecommissionCapacityOwner, ensure_decommission_capacity_mutation_id};
17use crate::multipart_listing::paginate_multipart_listing;
18use crate::set_disk::get_lock_acquire_timeout;
19use crate::storage_api_contracts::multipart::MultipartOperations as _;
20use crate::storage_api_contracts::object::ObjectOperations as _;
21use futures::{StreamExt, stream};
22use std::collections::HashSet;
23
24const MULTIPART_LIST_SET_CONCURRENCY: usize = 4;
25
26#[cfg(test)]
27static DATA_MOVEMENT_MULTIPART_DISCOVERY_COUNTS: std::sync::OnceLock<std::sync::Mutex<std::collections::HashMap<Uuid, usize>>> =
28 std::sync::OnceLock::new();
29
30#[cfg(test)]
31fn data_movement_multipart_discovery_counts() -> &'static std::sync::Mutex<std::collections::HashMap<Uuid, usize>> {
32 DATA_MOVEMENT_MULTIPART_DISCOVERY_COUNTS.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
33}
34
35fn decommission_multipart_target_clear_pending(opts: &ObjectOptions, target: Option<&ObjectInfo>) -> Result<bool> {
36 let expected_mod_time = opts.mod_time.ok_or_else(|| Error::DecommissionCapacityBlocked {
37 message: "multipart cleanup cannot prove exact target absence without a modification time".to_string(),
38 })?;
39 let expected_version_id = opts
40 .version_id
41 .as_deref()
42 .map(Uuid::parse_str)
43 .transpose()
44 .map_err(|err| Error::DecommissionCapacityBlocked {
45 message: format!("multipart cleanup exact target version is invalid: {err}"),
46 })?
47 .filter(|version_id| !version_id.is_nil());
48 let Some(target) = target else {
49 return Ok(true);
50 };
51 if target.version_id.filter(|version_id| !version_id.is_nil()) != expected_version_id
52 || target.mod_time != Some(expected_mod_time)
53 {
54 return Err(Error::DecommissionCapacityBlocked {
55 message: "multipart cleanup found a target but cannot prove the exact staged identity is absent".to_string(),
56 });
57 }
58 if !crate::data_movement::is_owned_data_movement_target(target) {
59 return Err(Error::DecommissionCapacityBlocked {
60 message: "multipart cleanup found an exact target without its ownership proof".to_string(),
61 });
62 }
63 Ok(false)
64}
65
66#[derive(Clone, Debug)]
67pub(super) struct MultipartUploadListRequest {
68 pub(super) prefix: String,
69 pub(super) key_marker: Option<String>,
70 pub(super) upload_id_marker: Option<String>,
71 pub(super) delimiter: Option<String>,
72 pub(super) max_uploads: usize,
73 pub(super) expected_incarnation_id: Option<Uuid>,
74}
75
76fn map_multipart_namespace_lock_error(
77 bucket: &str,
78 object: &str,
79 mode: &'static str,
80 err: rustfs_lock::LockError,
81) -> StorageError {
82 match err {
83 rustfs_lock::LockError::QuorumNotReached { required, achieved } => StorageError::NamespaceLockQuorumUnavailable {
84 mode,
85 bucket: bucket.to_string(),
86 object: object.to_string(),
87 required,
88 achieved,
89 },
90 other => StorageError::Lock(other),
91 }
92}
93
94fn ensure_multipart_bucket_lifecycle_guard_held(
95 guard: Option<&rustfs_lock::NamespaceLockGuard>,
96 bucket: &str,
97 object: &str,
98) -> Result<()> {
99 if guard.is_some_and(rustfs_lock::NamespaceLockGuard::is_lock_lost) {
100 return Err(StorageError::NamespaceLockQuorumUnavailable {
101 mode: "multipart_bucket_generation",
102 bucket: bucket.to_string(),
103 object: object.to_string(),
104 required: 1,
105 achieved: 0,
106 });
107 }
108 Ok(())
109}
110
111#[cfg(test)]
112struct DataMovementMultipartCompletionBarrierState {
113 bucket: String,
114 arrived: tokio::sync::Notify,
115 release: tokio::sync::Notify,
116}
117
118#[cfg(test)]
119pub(crate) struct DataMovementMultipartCompletionBarrier {
120 state: Arc<DataMovementMultipartCompletionBarrierState>,
121}
122
123#[cfg(test)]
124static DATA_MOVEMENT_MULTIPART_COMPLETION_BARRIER: std::sync::OnceLock<
125 std::sync::Mutex<Option<Arc<DataMovementMultipartCompletionBarrierState>>>,
126> = std::sync::OnceLock::new();
127
128#[cfg(test)]
129impl DataMovementMultipartCompletionBarrier {
130 pub(crate) fn install(bucket: &str) -> Self {
131 let state = Arc::new(DataMovementMultipartCompletionBarrierState {
132 bucket: bucket.to_string(),
133 arrived: tokio::sync::Notify::new(),
134 release: tokio::sync::Notify::new(),
135 });
136 let mut slot = DATA_MOVEMENT_MULTIPART_COMPLETION_BARRIER
137 .get_or_init(|| std::sync::Mutex::new(None))
138 .lock()
139 .expect("data movement multipart completion barrier mutex should not poison");
140 assert!(slot.is_none(), "data movement multipart completion barrier must be unique");
141 *slot = Some(Arc::clone(&state));
142 Self { state }
143 }
144
145 pub(crate) async fn wait_until_paused(&self) {
146 tokio::time::timeout(std::time::Duration::from_secs(30), self.state.arrived.notified())
147 .await
148 .expect("data movement multipart operation should reach selected completion");
149 }
150}
151
152#[cfg(test)]
153impl Drop for DataMovementMultipartCompletionBarrier {
154 fn drop(&mut self) {
155 self.state.release.notify_one();
156 let mut slot = DATA_MOVEMENT_MULTIPART_COMPLETION_BARRIER
157 .get_or_init(|| std::sync::Mutex::new(None))
158 .lock()
159 .expect("data movement multipart completion barrier mutex should not poison");
160 if slot.as_ref().is_some_and(|state| Arc::ptr_eq(state, &self.state)) {
161 *slot = None;
162 }
163 }
164}
165
166#[cfg(test)]
167async fn pause_data_movement_multipart_before_selected_completion(bucket: &str) {
168 let barrier = DATA_MOVEMENT_MULTIPART_COMPLETION_BARRIER
169 .get_or_init(|| std::sync::Mutex::new(None))
170 .lock()
171 .expect("data movement multipart completion barrier mutex should not poison")
172 .as_ref()
173 .filter(|barrier| barrier.bucket == bucket)
174 .cloned();
175 if let Some(barrier) = barrier {
176 barrier.arrived.notify_one();
177 barrier.release.notified().await;
178 }
179}
180
181async fn list_pool_multipart_uploads_for_incarnation(
182 pool: &crate::core::sets::Sets,
183 bucket: &str,
184 request: &MultipartUploadListRequest,
185) -> Result<ListMultipartsInfo> {
186 let per_set_limit = request.max_uploads.saturating_add(1);
187 let results = stream::iter(pool.disk_set.iter().cloned())
188 .map(|set| {
189 let request = request.clone();
190 async move {
191 set.list_multipart_uploads_for_incarnation(
192 bucket,
193 &request.prefix,
194 request.key_marker,
195 request.upload_id_marker,
196 request.delimiter,
197 per_set_limit,
198 request.expected_incarnation_id,
199 )
200 .await
201 }
202 })
203 .buffer_unordered(MULTIPART_LIST_SET_CONCURRENCY)
204 .collect::<Vec<_>>()
205 .await;
206
207 let mut uploads = Vec::new();
208 let mut common_prefixes = HashSet::new();
209 let mut source_truncated = false;
210 for result in results {
211 let page = result?;
212 uploads.extend(page.uploads);
213 common_prefixes.extend(page.common_prefixes);
214 source_truncated |= page.is_truncated;
215 }
216
217 let page = paginate_multipart_listing(
218 uploads,
219 common_prefixes.into_iter().collect(),
220 request.key_marker.as_deref(),
221 request.key_marker.as_ref().and(request.upload_id_marker.as_deref()),
222 request.max_uploads,
223 source_truncated,
224 );
225
226 Ok(ListMultipartsInfo {
227 key_marker: request.key_marker.clone(),
228 upload_id_marker: request.upload_id_marker.clone(),
229 next_key_marker: page.next_key_marker,
230 next_upload_id_marker: page.next_upload_id_marker,
231 max_uploads: request.max_uploads,
232 is_truncated: page.is_truncated,
233 uploads: page.uploads,
234 common_prefixes: page.common_prefixes,
235 prefix: request.prefix.clone(),
236 delimiter: request.delimiter.clone(),
237 })
238}
239
240impl ECStore {
241 #[cfg(all(test, feature = "test-util"))]
242 pub(crate) fn reset_data_movement_multipart_discovery_count_for_test(&self) {
243 data_movement_multipart_discovery_counts()
244 .lock()
245 .unwrap_or_else(std::sync::PoisonError::into_inner)
246 .insert(self.id, 0);
247 }
248
249 #[cfg(all(test, feature = "test-util"))]
250 pub(crate) fn data_movement_multipart_discovery_count_for_test(&self) -> usize {
251 data_movement_multipart_discovery_counts()
252 .lock()
253 .unwrap_or_else(std::sync::PoisonError::into_inner)
254 .get(&self.id)
255 .copied()
256 .unwrap_or_default()
257 }
258
259 pub(crate) async fn acquire_decommission_multipart_mutation_fence(
260 &self,
261 owner: DecommissionCapacityOwner,
262 ) -> Result<ObjectLockDiagGuard> {
263 let mutation_id = owner
264 .mutation_id
265 .ok_or_else(|| Error::other("decommission multipart mutation identity is missing"))?;
266 let object = format!(
267 "decommission-multipart/{}/{}/{}/{}",
268 owner.source_pool_index, owner.operation_id, owner.generation, mutation_id
269 );
270 self.acquire_object_write_lock("decommission_multipart_mutation", crate::disk::RUSTFS_META_MULTIPART_BUCKET, &object)
271 .await
272 }
273
274 async fn existing_multipart_pool_order(&self) -> Vec<usize> {
275 let mut active = Vec::with_capacity(self.pools.len());
278 let mut draining = Vec::new();
279 for (idx, pool) in self.pools.iter().enumerate() {
280 if self.is_pool_rebalancing(pool.pool_idx).await {
281 continue;
282 }
283 if self.is_suspended(pool.pool_idx).await {
284 draining.push(idx);
285 } else {
286 active.push(idx);
287 }
288 }
289 active.extend(draining);
290 active
291 }
292
293 async fn multipart_upload_pool_idx(
294 &self,
295 bucket: &str,
296 object: &str,
297 upload_id: &str,
298 opts: &ObjectOptions,
299 ) -> Result<usize> {
300 for pool_idx in self.existing_multipart_pool_order().await {
301 match self.pools[pool_idx].get_multipart_info(bucket, object, upload_id, opts).await {
302 Ok(_) => return Ok(pool_idx),
303 Err(err) if is_err_invalid_upload_id(&err) => continue,
304 Err(err) => return Err(err),
305 }
306 }
307
308 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
309 }
310
311 #[allow(clippy::too_many_arguments)]
312 pub async fn list_multipart_uploads_for_bucket_incarnation(
313 &self,
314 bucket: &str,
315 prefix: &str,
316 key_marker: Option<String>,
317 upload_id_marker: Option<String>,
318 delimiter: Option<String>,
319 max_uploads: usize,
320 expected_incarnation_id: Uuid,
321 ) -> Result<ListMultipartsInfo> {
322 self.handle_list_multipart_uploads(
323 bucket,
324 MultipartUploadListRequest {
325 prefix: prefix.to_string(),
326 key_marker,
327 upload_id_marker,
328 delimiter,
329 max_uploads,
330 expected_incarnation_id: Some(expected_incarnation_id),
331 },
332 )
333 .await
334 }
335
336 async fn guard_multipart_bucket_incarnation(
339 &self,
340 bucket: &str,
341 opts: &ObjectOptions,
342 ) -> Result<(ObjectOptions, Option<rustfs_lock::NamespaceLockGuard>)> {
343 let mut opts = opts.clone();
344 if is_meta_bucketname(bucket) {
345 return Ok((opts, None));
346 }
347 if opts.expected_bucket_incarnation_id.is_none() {
348 opts.expected_bucket_incarnation_id = Some(self.bucket_incarnation_id(bucket).await?);
349 }
350 let guard = if opts.bucket_lifecycle_lock_fence.is_some() {
351 None
352 } else {
353 Some(self.acquire_bucket_lifecycle_read_lock(bucket).await?)
354 };
355 if let Some(guard) = guard.as_ref() {
356 opts.add_bucket_lifecycle_lock_guard(guard);
357 }
358 let current = crate::bucket::metadata_sys::get_bucket_incarnation_id_for_options_in(&self.ctx, bucket, &opts).await?;
359 if opts.expected_bucket_incarnation_id != Some(current) {
360 return Err(StorageError::BucketNotFound(bucket.to_string()));
361 }
362 Ok((opts, guard))
363 }
364
365 async fn acquire_list_parts_read_lock(
366 &self,
367 bucket: &str,
368 object: &str,
369 opts: &ObjectOptions,
370 ) -> Result<Option<rustfs_lock::NamespaceLockGuard>> {
371 if opts.no_lock {
372 return Ok(None);
373 }
374
375 let ns_lock = self.handle_new_ns_lock(bucket, object).await?;
376 ns_lock
377 .get_read_lock(get_lock_acquire_timeout())
378 .await
379 .map(Some)
380 .map_err(|err| map_multipart_namespace_lock_error(bucket, object, "read", err))
381 }
382
383 #[instrument(skip(self))]
384 pub(super) async fn handle_list_object_parts(
385 &self,
386 bucket: &str,
387 object: &str,
388 upload_id: &str,
389 part_number_marker: Option<usize>,
390 max_parts: usize,
391 opts: &ObjectOptions,
392 ) -> Result<ListPartsInfo> {
393 check_list_parts_args(bucket, object, upload_id)?;
394 let (opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
395 let opts = &opts;
396
397 let _object_lock_guard = self.acquire_list_parts_read_lock(bucket, object, opts).await?;
398
399 if self.single_pool() {
400 return self.pools[0]
401 .list_object_parts(bucket, object, upload_id, part_number_marker, max_parts, opts)
402 .await;
403 }
404
405 for pool_idx in self.existing_multipart_pool_order().await {
406 let pool = &self.pools[pool_idx];
407 return match pool
408 .list_object_parts(bucket, object, upload_id, part_number_marker, max_parts, opts)
409 .await
410 {
411 Ok(res) => Ok(res),
412 Err(err) => {
413 if is_err_invalid_upload_id(&err) {
414 continue;
415 }
416 Err(err)
417 }
418 };
419 }
420
421 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
422 }
423
424 #[instrument(skip(self))]
425 pub(super) async fn handle_list_multipart_uploads(
426 &self,
427 bucket: &str,
428 request: MultipartUploadListRequest,
429 ) -> Result<ListMultipartsInfo> {
430 check_list_multipart_args(
431 bucket,
432 &request.prefix,
433 &request.key_marker,
434 &request.upload_id_marker,
435 &request.delimiter,
436 )?;
437 let guard_opts = ObjectOptions {
438 expected_bucket_incarnation_id: request.expected_incarnation_id,
439 ..Default::default()
440 };
441 let (opts, bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, &guard_opts).await?;
442 let expected_incarnation_id = opts.expected_bucket_incarnation_id;
443
444 if request.prefix.is_empty() {
445 }
447
448 if self.single_pool() {
449 let result = list_pool_multipart_uploads_for_incarnation(
450 &self.pools[0],
451 bucket,
452 &MultipartUploadListRequest {
453 expected_incarnation_id,
454 ..request.clone()
455 },
456 )
457 .await;
458 ensure_multipart_bucket_lifecycle_guard_held(bucket_lifecycle_guard.as_ref(), bucket, &request.prefix)?;
459 return result;
460 }
461
462 let mut uploads = Vec::new();
463 let mut common_prefixes = HashSet::new();
464 let mut source_truncated = false;
465
466 for pool_idx in self.existing_multipart_pool_order().await {
467 let pool = &self.pools[pool_idx];
468 let res = list_pool_multipart_uploads_for_incarnation(
469 pool,
470 bucket,
471 &MultipartUploadListRequest {
472 expected_incarnation_id,
473 ..request.clone()
474 },
475 )
476 .await?;
477 uploads.extend(res.uploads);
478 common_prefixes.extend(res.common_prefixes);
479 source_truncated |= res.is_truncated;
480 }
481
482 let page =
487 merge_multipart_upload_pages(uploads, common_prefixes.into_iter().collect(), request.max_uploads, source_truncated);
488 ensure_multipart_bucket_lifecycle_guard_held(bucket_lifecycle_guard.as_ref(), bucket, &request.prefix)?;
489
490 Ok(ListMultipartsInfo {
491 key_marker: request.key_marker,
492 upload_id_marker: request.upload_id_marker,
493 next_key_marker: page.next_key_marker,
494 next_upload_id_marker: page.next_upload_id_marker,
495 max_uploads: request.max_uploads,
496 is_truncated: page.is_truncated,
497 uploads: page.uploads,
498 common_prefixes: page.common_prefixes,
499 prefix: request.prefix,
500 delimiter: request.delimiter,
501 })
502 }
503
504 #[instrument(skip(self))]
505 pub(super) async fn handle_new_multipart_upload(
506 &self,
507 bucket: &str,
508 object: &str,
509 opts: &ObjectOptions,
510 ) -> Result<MultipartUploadResult> {
511 self.handle_new_multipart_upload_with_pool_idx(bucket, object, opts, None)
512 .await
513 .map(|(res, _, _)| res)
514 }
515
516 pub(crate) async fn handle_new_multipart_upload_with_pool_idx(
517 &self,
518 bucket: &str,
519 object: &str,
520 opts: &ObjectOptions,
521 mutation_fence: Option<&ObjectLockDiagGuard>,
522 ) -> Result<(MultipartUploadResult, usize, Option<Uuid>)> {
523 check_new_multipart_args(bucket, object)?;
524 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
525
526 if self.single_pool() {
527 self.apply_decommission_target_mutation_fence(0, object, &mut opts, mutation_fence)
528 .await;
529 let result = self.pools[0].new_multipart_upload(bucket, object, &opts).await?;
530 return Ok((result, 0, opts.expected_bucket_incarnation_id));
531 }
532
533 let capacity_owner = DecommissionCapacityOwner::from_options(&opts);
534 if opts.data_movement && (opts.version_id.is_some() || capacity_owner.is_some()) {
535 let idx = self.select_data_movement_pool_idx(bucket, object, -1, &opts, false).await?;
539 if idx == opts.src_pool_idx {
540 return Err(StorageError::DataMovementOverwriteErr(
541 bucket.to_owned(),
542 object.to_owned(),
543 opts.version_id.clone().unwrap_or_default(),
544 ));
545 }
546 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
547 .await;
548 let res = self
549 .run_decommission_capacity_temporary_mutation(idx, capacity_owner, None, || async {
550 self.pools[idx].new_multipart_upload(bucket, object, &opts).await
551 })
552 .await?;
553 return Ok((res, idx, opts.expected_bucket_incarnation_id));
554 }
555
556 for (idx, pool) in self.pools.iter().enumerate() {
557 if self.is_suspended(idx).await || self.is_pool_rebalancing(idx).await {
558 continue;
559 }
560 let res = list_pool_multipart_uploads_for_incarnation(
561 pool,
562 bucket,
563 &MultipartUploadListRequest {
564 prefix: object.to_string(),
565 key_marker: None,
566 upload_id_marker: None,
567 delimiter: None,
568 max_uploads: MAX_UPLOADS_LIST,
569 expected_incarnation_id: opts.expected_bucket_incarnation_id,
570 },
571 )
572 .await?;
573
574 if !res.uploads.is_empty() {
575 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
576 .await;
577 let expected_bucket_incarnation_id = opts.expected_bucket_incarnation_id;
578 let lock_object = encode_dir_object(object);
579 let res = self
580 .run_external_decommission_capacity_object_mutation(
581 idx,
582 bucket,
583 &lock_object,
584 object,
585 opts,
586 |opts| async move { self.pools[idx].new_multipart_upload(bucket, object, &opts).await },
587 )
588 .await?;
589 return Ok((res, idx, expected_bucket_incarnation_id));
590 }
591 }
592 let idx = self.get_pool_idx(bucket, object, -1).await?;
593 if opts.data_movement && idx == opts.src_pool_idx {
594 return Err(StorageError::DataMovementOverwriteErr(
595 bucket.to_owned(),
596 object.to_owned(),
597 "".to_owned(),
598 ));
599 }
600
601 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
602 .await;
603 let expected_bucket_incarnation_id = opts.expected_bucket_incarnation_id;
604 let res = if opts.data_movement {
605 self.run_decommission_capacity_temporary_mutation(
606 idx,
607 DecommissionCapacityOwner::from_options(&opts),
608 None,
609 || async { self.pools[idx].new_multipart_upload(bucket, object, &opts).await },
610 )
611 .await?
612 } else {
613 let lock_object = encode_dir_object(object);
614 self.run_external_decommission_capacity_object_mutation(idx, bucket, &lock_object, object, opts, |opts| async move {
615 self.pools[idx].new_multipart_upload(bucket, object, &opts).await
616 })
617 .await?
618 };
619 Ok((res, idx, expected_bucket_incarnation_id))
620 }
621
622 #[instrument(skip(self))]
623 #[allow(clippy::too_many_arguments)]
624 pub(super) async fn handle_copy_object_part(
625 &self,
626 src_bucket: &str,
627 src_object: &str,
628 _dst_bucket: &str,
629 _dst_object: &str,
630 _upload_id: &str,
631 _part_id: usize,
632 _start_offset: i64,
633 _length: i64,
634 _src_info: &ObjectInfo,
635 _src_opts: &ObjectOptions,
636 _dst_opts: &ObjectOptions,
637 ) -> Result<()> {
638 check_new_multipart_args(src_bucket, src_object)?;
639
640 Err(StorageError::NotImplemented)
643 }
644
645 #[instrument(skip(self, data))]
646 #[hotpath::measure(impl_type = "ECStore")]
647 pub(super) async fn handle_put_object_part(
648 &self,
649 bucket: &str,
650 object: &str,
651 upload_id: &str,
652 part_id: usize,
653 data: &mut PutObjReader,
654 opts: &ObjectOptions,
655 ) -> Result<PartInfo> {
656 check_put_object_part_args(bucket, object, upload_id)?;
657 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
658 if !self.single_pool() {
659 opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
660 }
661 let opts = &opts;
662
663 if self.single_pool() {
664 return self.pools[0]
665 .put_object_part(bucket, object, upload_id, part_id, data, opts)
666 .await;
667 }
668
669 let pool_idx = self.multipart_upload_pool_idx(bucket, object, upload_id, opts).await?;
670 self.pools[pool_idx]
671 .put_object_part(bucket, object, upload_id, part_id, data, opts)
672 .await
673 }
674
675 pub(crate) async fn put_object_part_for_data_movement(
676 &self,
677 target_pool_idx: usize,
678 bucket: &str,
679 object: &str,
680 upload_id: &str,
681 data: &mut PutObjReader,
682 opts: &ObjectOptions,
683 ) -> Result<PartInfo> {
684 let part_id = opts
685 .part_number
686 .ok_or_else(|| Error::other("targeted multipart upload requires a part number"))?;
687 check_put_object_part_args(bucket, object, upload_id)?;
688 if !opts.data_movement {
689 return Err(Error::other("targeted multipart upload requires data_movement options"));
690 }
691 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
692 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
693 let pool = self.pools.get(target_pool_idx).ok_or_else(|| {
694 Error::InvalidArgument("data-movement".to_string(), "target-pool".to_string(), target_pool_idx.to_string())
695 })?;
696 let expected_data_bytes = usize::try_from(data.size()).ok();
697 self.run_decommission_capacity_temporary_mutation_with_capacity_lease(
698 target_pool_idx,
699 DecommissionCapacityOwner::from_options(&opts),
700 expected_data_bytes,
701 |capacity_lease| async move {
702 if let Some(capacity_lease) = capacity_lease {
703 opts.add_namespace_lock_lost_signal(capacity_lease);
704 }
705 pool.put_object_part(bucket, object, upload_id, part_id, data, &opts).await
706 },
707 )
708 .await
709 }
710
711 #[instrument(skip(self))]
712 pub(super) async fn handle_get_multipart_info(
713 &self,
714 bucket: &str,
715 object: &str,
716 upload_id: &str,
717 opts: &ObjectOptions,
718 ) -> Result<MultipartInfo> {
719 check_list_parts_args(bucket, object, upload_id)?;
720 let (opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
721 let opts = &opts;
722 if self.single_pool() {
723 return self.pools[0].get_multipart_info(bucket, object, upload_id, opts).await;
724 }
725
726 for pool_idx in self.existing_multipart_pool_order().await {
727 let pool = &self.pools[pool_idx];
728
729 return match pool.get_multipart_info(bucket, object, upload_id, opts).await {
730 Ok(res) => Ok(res),
731 Err(err) => {
732 if is_err_invalid_upload_id(&err) {
733 continue;
734 }
735
736 Err(err)
737 }
738 };
739 }
740
741 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
742 }
743
744 #[instrument(skip(self))]
745 pub(super) async fn handle_abort_multipart_upload(
746 &self,
747 bucket: &str,
748 object: &str,
749 upload_id: &str,
750 opts: &ObjectOptions,
751 ) -> Result<()> {
752 check_abort_multipart_args(bucket, object, upload_id)?;
753 let (opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
754 let opts = &opts;
755
756 if self.single_pool() {
759 return self.pools[0].abort_multipart_upload(bucket, object, upload_id, opts).await;
760 }
761
762 for pool_idx in self.existing_multipart_pool_order().await {
763 let pool = &self.pools[pool_idx];
764
765 let err = match pool.abort_multipart_upload(bucket, object, upload_id, opts).await {
766 Ok(_) => return Ok(()),
767 Err(err) => {
768 if is_err_invalid_upload_id(&err) { None } else { Some(err) }
770 }
771 };
772
773 if let Some(er) = err {
774 return Err(er);
775 }
776 }
777
778 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
779 }
780
781 pub(crate) async fn abort_multipart_upload_for_data_movement(
782 &self,
783 target_pool_idx: usize,
784 bucket: &str,
785 object: &str,
786 upload_id: &str,
787 opts: &ObjectOptions,
788 ) -> Result<()> {
789 let upload_identity = crate::data_movement::data_movement_upload_identity_from_options(opts);
790 self.abort_multipart_uploads_for_data_movement(
791 target_pool_idx,
792 bucket,
793 object,
794 &[upload_id.to_owned()],
795 &upload_identity,
796 opts,
797 )
798 .await
799 }
800
801 pub(crate) async fn reconcile_multipart_uploads_for_data_movement(
802 &self,
803 target_pool_idx: usize,
804 bucket: &str,
805 object: &str,
806 upload_identity: &str,
807 opts: &ObjectOptions,
808 ) -> Result<()> {
809 self.pools
810 .get(target_pool_idx)
811 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?;
812 let owner = DecommissionCapacityOwner::from_options(opts)
813 .ok_or_else(|| Error::other("data movement multipart cleanup is missing its capacity owner"))?;
814 if !self
815 .decommission_capacity_cleanup_target_indices(owner)
816 .await?
817 .contains(&target_pool_idx)
818 {
819 return Err(Error::DecommissionCapacityBlocked {
820 message: format!(
821 "data movement multipart cleanup target pool {target_pool_idx} is outside its capacity reservation"
822 ),
823 });
824 }
825 if !self
826 .has_decommission_capacity_temporary_mutation_state(target_pool_idx, owner)
827 .await
828 {
829 return Ok(());
830 }
831 #[cfg(test)]
832 {
833 *data_movement_multipart_discovery_counts()
834 .lock()
835 .unwrap_or_else(std::sync::PoisonError::into_inner)
836 .entry(self.id)
837 .or_default() += 1;
838 }
839 self.abort_multipart_uploads_for_data_movement(target_pool_idx, bucket, object, &[], upload_identity, opts)
840 .await
841 }
842
843 async fn abort_multipart_uploads_for_data_movement(
844 &self,
845 target_pool_idx: usize,
846 bucket: &str,
847 object: &str,
848 upload_ids: &[String],
849 expected_upload_identity: &str,
850 opts: &ObjectOptions,
851 ) -> Result<()> {
852 check_new_multipart_args(bucket, object)?;
853 for upload_id in upload_ids {
854 check_abort_multipart_args(bucket, object, upload_id)?;
855 }
856 if !opts.data_movement {
857 return Err(Error::other("targeted multipart abort requires data_movement options"));
858 }
859 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
860 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
861 let capacity_owner = DecommissionCapacityOwner::from_options(&opts);
862 let pool = self
863 .pools
864 .get(target_pool_idx)
865 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?;
866 opts.no_lock = true;
867 let set = pool.get_disks_by_key(object);
868 let (cleanup_decision_error, guards) = self
871 .run_decommission_capacity_temporary_release_with_capacity_lease(target_pool_idx, capacity_owner, |capacity_lease| {
872 let mut delete_opts = opts.clone();
873 let set = &set;
874 let pool = &pool;
875 async move {
876 if let Some(capacity_lease) = capacity_lease.as_ref() {
877 delete_opts.add_namespace_lock_lost_signal(Arc::clone(capacity_lease));
878 }
879 let mut candidate_upload_ids = upload_ids.to_vec();
880 candidate_upload_ids.extend(
881 set.data_movement_multipart_upload_ids(
882 bucket,
883 object,
884 delete_opts.expected_bucket_incarnation_id,
885 expected_upload_identity,
886 )
887 .await?,
888 );
889 candidate_upload_ids.sort_unstable();
890 candidate_upload_ids.dedup();
891
892 let mut guards = Vec::with_capacity(candidate_upload_ids.len());
893 for upload_id in &candidate_upload_ids {
894 match set
895 .lock_data_movement_multipart_abort(
896 bucket,
897 object,
898 upload_id,
899 Some(expected_upload_identity),
900 &delete_opts,
901 )
902 .await
903 {
904 Ok(Some(guard)) => {
905 guard.add_namespace_lock_fence(&mut delete_opts);
906 guards.push(guard);
907 }
908 Ok(None) => {}
909 Err(err) => return Err(err),
910 }
911 }
912 for guard in &guards {
913 match guard.delete(set, bucket, object, &delete_opts).await {
914 Ok(()) => {}
915 Err(err) if is_err_invalid_upload_id(&err) => {}
916 Err(err) => return Err(err),
917 }
918 }
919
920 if !set
921 .data_movement_multipart_upload_ids(
922 bucket,
923 object,
924 delete_opts.expected_bucket_incarnation_id,
925 expected_upload_identity,
926 )
927 .await?
928 .is_empty()
929 {
930 return Err(Error::DecommissionCapacityBlocked {
931 message: "multipart cleanup could not prove the exact staged uploads are absent".to_string(),
932 });
933 }
934
935 let (clear_pending, cleanup_decision_error) = if capacity_owner.is_some() {
939 let mut lookup_opts = ObjectOptions {
940 versioned: delete_opts.versioned,
941 version_suspended: delete_opts.version_suspended,
942 version_id: delete_opts.version_id.clone(),
943 metadata_chg: delete_opts.version_id.is_some(),
944 no_lock: true,
945 ..Default::default()
946 };
947 if let Some(capacity_lease) = capacity_lease {
948 lookup_opts.add_namespace_lock_lost_signal(capacity_lease);
949 }
950 let target = match pool.get_object_info(bucket, object, &lookup_opts).await {
951 Ok(target) => Some(target),
952 Err(err) if is_err_object_not_found(&err) || is_err_version_not_found(&err) => None,
953 Err(err) => return Err(err),
954 };
955 match decommission_multipart_target_clear_pending(&delete_opts, target.as_ref()) {
956 Ok(clear_pending) => (clear_pending, None),
957 Err(err) => (false, Some(err)),
958 }
959 } else {
960 (true, None)
961 };
962 Ok(((cleanup_decision_error, guards), clear_pending))
963 }
964 })
965 .await?;
966 drop(guards);
967 if let Some(err) = cleanup_decision_error {
968 return Err(err);
969 }
970 Ok(())
971 }
972
973 #[instrument(skip(self))]
974 pub(super) async fn handle_complete_multipart_upload(
975 self: Arc<Self>,
976 bucket: &str,
977 object: &str,
978 upload_id: &str,
979 uploaded_parts: Vec<CompletePart>,
980 opts: &ObjectOptions,
981 ) -> Result<ObjectInfo> {
982 check_complete_multipart_args(bucket, object, upload_id)?;
983 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
984 if !self.single_pool() {
985 opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
986 }
987 let opts = &opts;
988
989 if self.single_pool() {
990 return self.pools[0]
991 .clone()
992 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts, opts)
993 .await;
994 }
995
996 match self.multipart_upload_pool_idx(bucket, object, upload_id, opts).await {
997 Ok(pool_idx) => {
998 self.pools[pool_idx]
999 .clone()
1000 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts, opts)
1001 .await
1002 }
1003 Err(err) if is_err_invalid_upload_id(&err) => {
1006 let mut missing = err;
1007 for pool_idx in self.existing_multipart_pool_order().await {
1008 match self.pools[pool_idx]
1009 .clone()
1010 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts.clone(), opts)
1011 .await
1012 {
1013 Ok(info) => return Ok(info),
1014 Err(err) if is_err_invalid_upload_id(&err) => missing = err,
1015 Err(err) => return Err(err),
1016 }
1017 }
1018 Err(missing)
1019 }
1020 Err(err) => Err(err),
1021 }
1022 }
1023
1024 #[cfg(all(test, feature = "test-util"))]
1025 pub(crate) async fn complete_multipart_upload_for_data_movement(
1026 self: Arc<Self>,
1027 target: (usize, Option<&ObjectLockDiagGuard>),
1028 bucket: &str,
1029 object: &str,
1030 upload_id: &str,
1031 uploaded_parts: Vec<CompletePart>,
1032 opts: &ObjectOptions,
1033 ) -> Result<ObjectInfo> {
1034 self.complete_multipart_upload_for_data_movement_inner(target, bucket, object, upload_id, uploaded_parts, opts, None)
1035 .await
1036 }
1037
1038 #[allow(clippy::too_many_arguments)]
1039 pub(crate) async fn complete_multipart_upload_for_data_movement_with_publication_fence(
1040 self: Arc<Self>,
1041 target_pool_idx: usize,
1042 bucket: &str,
1043 object: &str,
1044 upload_id: &str,
1045 uploaded_parts: Vec<CompletePart>,
1046 opts: &ObjectOptions,
1047 publication_fence: RemoteTuplePublicationFence,
1048 ) -> Result<ObjectInfo> {
1049 self.complete_multipart_upload_for_data_movement_inner(
1050 (target_pool_idx, None),
1051 bucket,
1052 object,
1053 upload_id,
1054 uploaded_parts,
1055 opts,
1056 Some(publication_fence),
1057 )
1058 .await
1059 }
1060
1061 #[allow(clippy::too_many_arguments)]
1062 async fn complete_multipart_upload_for_data_movement_inner(
1063 self: Arc<Self>,
1064 target: (usize, Option<&ObjectLockDiagGuard>),
1065 bucket: &str,
1066 object: &str,
1067 upload_id: &str,
1068 uploaded_parts: Vec<CompletePart>,
1069 opts: &ObjectOptions,
1070 publication_fence: Option<RemoteTuplePublicationFence>,
1071 ) -> Result<ObjectInfo> {
1072 let request_opts = opts;
1073 let (target_pool_idx, mutation_fence) = target;
1074 check_complete_multipart_args(bucket, object, upload_id)?;
1075 if !opts.data_movement {
1076 return Err(Error::other("targeted multipart completion requires data_movement options"));
1077 }
1078 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
1079 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
1080 if opts.overwrites_existing_version() && !is_meta_bucketname(bucket) {
1081 let expected_incarnation_id = opts
1082 .expected_bucket_incarnation_id
1083 .ok_or_else(|| Error::other("data movement completion is missing its bucket incarnation"))?;
1084 let lifecycle_fence = opts
1085 .bucket_lifecycle_lock_fence
1086 .as_ref()
1087 .ok_or_else(|| Error::other("data movement completion is missing its bucket lifecycle fence"))?;
1088 let snapshot = match opts.object_lock_config_snapshot.as_ref() {
1089 Some(snapshot) => Arc::clone(snapshot),
1090 None => {
1091 self.object_lock_config_snapshot_under_lifecycle_fence(bucket, lifecycle_fence)
1092 .await?
1093 }
1094 };
1095 if !snapshot.is_valid_for_destructive_put(self.id, bucket, expected_incarnation_id) {
1096 return Err(Error::other(
1097 "data movement Object Lock snapshot does not match the target bucket generation",
1098 ));
1099 }
1100 snapshot.add_lock_fences(&mut opts);
1101 opts.object_lock_config_snapshot = Some(snapshot);
1102 }
1103 let fixed_read_anchor = publication_fence
1104 .as_ref()
1105 .and_then(RemoteTuplePublicationFence::fixed_read_anchor_guard);
1106 self.apply_decommission_target_mutation_fence(target_pool_idx, object, &mut opts, mutation_fence.or(fixed_read_anchor))
1107 .await;
1108 let publication_object = encode_dir_object(object);
1112 let publication_guard = match publication_fence {
1113 Some(publication_fence) => {
1114 let guard = publication_fence
1115 .into_commit_guard(target_pool_idx, bucket, &publication_object)
1116 .await?;
1117 guard.add_namespace_lock_fence(&mut opts);
1118 opts.no_lock = true;
1119 Some(guard)
1120 }
1121 None => {
1122 if rustfs_utils::http::metadata_compat::contains_key_str(
1123 &opts.user_defined,
1124 rustfs_utils::http::SUFFIX_TRANSITION_STATUS,
1125 ) {
1126 return Err(Error::other(
1127 "data movement multipart completion cannot publish transition ownership without a publication capability",
1128 ));
1129 }
1130 None
1131 }
1132 };
1133 #[cfg(test)]
1134 pause_data_movement_multipart_before_selected_completion(bucket).await;
1135 let pool = self
1136 .pools
1137 .get(target_pool_idx)
1138 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?
1139 .clone();
1140 let result = self
1144 .run_decommission_capacity_admitted_mutation_with_capacity_lease(
1145 target_pool_idx,
1146 DecommissionCapacityOwner::from_options(&opts),
1147 opts.capacity_expected_data_bytes(),
1148 |capacity_lease| async move {
1149 if let Some(capacity_lease) = capacity_lease {
1150 opts.add_namespace_lock_lost_signal(capacity_lease);
1151 }
1152 pool.complete_multipart_upload(bucket, object, upload_id, uploaded_parts, &opts)
1153 .await
1154 },
1155 )
1156 .await;
1157 drop(publication_guard);
1158 let result =
1159 enqueue_transition_after_write(self.as_ref(), result, LcEventSrc::S3CompleteMultipartUpload, request_opts).await;
1160 if result.is_ok() {
1161 list_objects::observe_list_objects_mutation(self.as_ref(), bucket).await;
1162 }
1163 result
1164 }
1165}
1166
1167fn merge_multipart_upload_pages(
1177 uploads: Vec<MultipartInfo>,
1178 common_prefixes: Vec<String>,
1179 max_uploads: usize,
1180 source_truncated: bool,
1181) -> crate::multipart_listing::MultipartListingPage {
1182 paginate_multipart_listing(uploads, common_prefixes, None, None, max_uploads, source_truncated)
1183}
1184
1185#[cfg(test)]
1186mod tests {
1187 use super::*;
1188 use crate::layout::{
1189 endpoints::{Endpoints, PoolEndpoints},
1190 format::FormatV3,
1191 };
1192 use std::time::Duration;
1193
1194 fn mp(object: &str, upload_id: &str) -> MultipartInfo {
1195 MultipartInfo {
1196 bucket: "bucket".to_string(),
1197 object: object.to_string(),
1198 upload_id: upload_id.to_string(),
1199 initiated: None,
1200 ..Default::default()
1201 }
1202 }
1203
1204 #[test]
1205 fn decommission_multipart_cleanup_requires_exact_target_evidence() {
1206 let version_id = Uuid::new_v4();
1207 let mod_time = time::OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(7);
1208 let opts = ObjectOptions {
1209 versioned: true,
1210 version_id: Some(version_id.to_string()),
1211 mod_time: Some(mod_time),
1212 ..Default::default()
1213 };
1214
1215 assert!(
1216 decommission_multipart_target_clear_pending(&opts, None)
1217 .expect("an exact target miss should authorize pending cleanup")
1218 );
1219
1220 let mut metadata = HashMap::new();
1221 rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_DATA_MOVED, "true".to_string());
1222 rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_DATA_MOVED_TAGS, "v1:".to_string());
1223 let owned_target = ObjectInfo {
1224 version_id: Some(version_id),
1225 mod_time: Some(mod_time),
1226 user_defined: Arc::new(metadata),
1227 ..Default::default()
1228 };
1229 assert!(
1230 !decommission_multipart_target_clear_pending(&opts, Some(&owned_target))
1231 .expect("an exact owned target should preserve pending capacity")
1232 );
1233
1234 let missing_identity = ObjectOptions {
1235 mod_time: None,
1236 ..opts.clone()
1237 };
1238 assert!(matches!(
1239 decommission_multipart_target_clear_pending(&missing_identity, None),
1240 Err(Error::DecommissionCapacityBlocked { .. })
1241 ));
1242
1243 let mismatched_target = ObjectInfo {
1244 version_id: Some(Uuid::new_v4()),
1245 mod_time: Some(mod_time),
1246 ..Default::default()
1247 };
1248 assert!(matches!(
1249 decommission_multipart_target_clear_pending(&opts, Some(&mismatched_target)),
1250 Err(Error::DecommissionCapacityBlocked { .. })
1251 ));
1252
1253 let unowned_target = ObjectInfo {
1254 version_id: Some(version_id),
1255 mod_time: Some(mod_time),
1256 ..Default::default()
1257 };
1258 assert!(matches!(
1259 decommission_multipart_target_clear_pending(&opts, Some(&unowned_target)),
1260 Err(Error::DecommissionCapacityBlocked { .. })
1261 ));
1262 }
1263
1264 fn pool_query(
1268 pool: &[MultipartInfo],
1269 key_marker: Option<&str>,
1270 upload_id_marker: Option<&str>,
1271 max_uploads: usize,
1272 ) -> Vec<MultipartInfo> {
1273 pool.iter()
1274 .filter(|u| match (key_marker, upload_id_marker) {
1275 (Some(k), Some(uid)) => (u.object.as_str(), u.upload_id.as_str()) > (k, uid),
1276 (Some(k), None) => u.object.as_str() > k,
1277 _ => true,
1278 })
1279 .take(max_uploads)
1280 .cloned()
1281 .collect()
1282 }
1283
1284 #[test]
1285 fn merge_multipart_upload_pages_sorts_and_caps_across_pools() {
1286 let uploads = vec![mp("b", "u1"), mp("a", "u2"), mp("a", "u1"), mp("c", "u1"), mp("b", "u2")];
1288
1289 let page = merge_multipart_upload_pages(uploads, Vec::new(), 3, false);
1290
1291 assert!(page.is_truncated);
1292 assert_eq!(page.uploads.len(), 3);
1293 let ordered: Vec<(&str, &str)> = page
1294 .uploads
1295 .iter()
1296 .map(|u| (u.object.as_str(), u.upload_id.as_str()))
1297 .collect();
1298 assert_eq!(ordered, vec![("a", "u1"), ("a", "u2"), ("b", "u1")]);
1299 assert_eq!(page.next_key_marker.as_deref(), Some("b"));
1300 assert_eq!(page.next_upload_id_marker.as_deref(), Some("u1"));
1301 }
1302
1303 #[test]
1304 fn merge_multipart_upload_pages_reports_complete_within_cap() {
1305 let uploads = vec![mp("b", "u1"), mp("a", "u1")];
1306
1307 let page = merge_multipart_upload_pages(uploads, Vec::new(), 3, false);
1308
1309 assert_eq!(page.uploads.len(), 2);
1310 assert!(!page.is_truncated);
1311 assert!(page.next_key_marker.is_none());
1312 assert!(page.next_upload_id_marker.is_none());
1313 }
1314
1315 #[test]
1316 fn merge_multipart_upload_pages_paginates_across_pools_without_loss() {
1317 let pool0 = vec![mp("a", "u1"), mp("a", "u3"), mp("c", "u1"), mp("e", "u1")];
1320 let pool1 = vec![mp("a", "u2"), mp("b", "u1"), mp("d", "u1"), mp("f", "u1")];
1321
1322 let mut expected: Vec<(String, String)> = pool0
1323 .iter()
1324 .chain(pool1.iter())
1325 .map(|u| (u.object.clone(), u.upload_id.clone()))
1326 .collect();
1327 expected.sort();
1328
1329 let max_uploads = 3;
1330 let mut key_marker: Option<String> = None;
1331 let mut upload_id_marker: Option<String> = None;
1332 let mut collected: Vec<(String, String)> = Vec::new();
1333
1334 for _ in 0..16 {
1335 let mut merged = Vec::new();
1336 for pool in [&pool0, &pool1] {
1337 merged.extend(pool_query(pool, key_marker.as_deref(), upload_id_marker.as_deref(), max_uploads));
1338 }
1339
1340 let page = merge_multipart_upload_pages(merged, Vec::new(), max_uploads, false);
1341 assert!(page.uploads.len() <= max_uploads);
1342 collected.extend(page.uploads.iter().map(|u| (u.object.clone(), u.upload_id.clone())));
1343
1344 if !page.is_truncated {
1345 break;
1346 }
1347 key_marker = page.next_key_marker;
1348 upload_id_marker = page.next_upload_id_marker;
1349 }
1350
1351 assert_eq!(collected, expected, "pagination must return every upload exactly once, in sorted order");
1352 let mut deduped = collected.clone();
1353 deduped.dedup();
1354 assert_eq!(deduped.len(), collected.len(), "pagination must not duplicate uploads");
1355 }
1356
1357 #[test]
1358 fn merge_multipart_upload_pages_includes_common_prefixes() {
1359 let page = merge_multipart_upload_pages(
1360 vec![mp("logs/root.bin", "u1")],
1361 vec!["logs/2026/".to_string(), "logs/2025/".to_string()],
1362 2,
1363 false,
1364 );
1365
1366 assert!(page.is_truncated);
1367 assert!(page.uploads.is_empty());
1368 assert_eq!(page.common_prefixes, vec!["logs/2025/", "logs/2026/"]);
1369 assert_eq!(page.next_key_marker.as_deref(), Some("logs/2026/"));
1370 assert!(page.next_upload_id_marker.is_none());
1371 }
1372
1373 #[test]
1374 fn merge_multipart_upload_pages_preserves_pool_truncation() {
1375 let page = merge_multipart_upload_pages(vec![mp("a", "u1")], Vec::new(), 1, true);
1376
1377 assert!(page.is_truncated);
1378 assert_eq!(page.next_key_marker.as_deref(), Some("a"));
1379 assert_eq!(page.next_upload_id_marker.as_deref(), Some("u1"));
1380 }
1381
1382 async fn new_multipart_lock_test_store() -> ECStore {
1383 let format = FormatV3::new(1, 2);
1384 let endpoints = vec![
1385 Endpoint::try_from("http://127.0.0.1:9000/data0").expect("first endpoint should parse"),
1386 Endpoint::try_from("http://127.0.0.1:9001/data1").expect("second endpoint should parse"),
1387 ];
1388 let pool_endpoints = PoolEndpoints {
1389 legacy: false,
1390 set_count: 1,
1391 drives_per_set: 2,
1392 endpoints: Endpoints::from(endpoints),
1393 cmd_line: "multipart-list-parts-lock-test".to_string(),
1394 platform: "test".to_string(),
1395 };
1396 let endpoint_pools = EndpointServerPools::from(vec![pool_endpoints.clone()]);
1397 let sets = Sets::new(vec![None, None], &pool_endpoints, &format, 0, 1)
1398 .await
1399 .expect("test sets should be created with empty disks");
1400
1401 ECStore {
1402 id: Uuid::new_v4(),
1403 disk_map: HashMap::new(),
1404 pools: vec![sets],
1405 peer_sys: S3PeerSys::new(&endpoint_pools),
1406 pool_meta: RwLock::new(PoolMeta::default()),
1407 rebalance_meta: RwLock::new(None),
1408 decommission_cancelers: RwLock::new(Vec::new()),
1409 start_gate: Mutex::new(()),
1410 pool_meta_save_gate: Mutex::default(),
1411 ctx: crate::runtime::instance::bootstrap_ctx(),
1412 bucket_fence_registry: std::sync::Arc::default(),
1413 }
1414 }
1415
1416 #[tokio::test]
1417 async fn list_parts_read_lock_blocks_object_writer_until_released() {
1418 let store = new_multipart_lock_test_store().await;
1419 let read_guard = store
1420 .acquire_list_parts_read_lock("bucket", "object", &ObjectOptions::default())
1421 .await
1422 .expect("list parts read lock should be acquired")
1423 .expect("default options should acquire a read lock");
1424
1425 let object_lock = store
1426 .handle_new_ns_lock("bucket", "object")
1427 .await
1428 .expect("object namespace lock should be created");
1429 let err = object_lock
1430 .get_write_lock(Duration::from_millis(20))
1431 .await
1432 .expect_err("list parts read lock should block object writers");
1433 assert!(matches!(err, rustfs_lock::LockError::Timeout { .. }));
1434
1435 drop(read_guard);
1436 object_lock
1437 .get_write_lock(Duration::from_secs(1))
1438 .await
1439 .expect("object writer should proceed after list parts releases the read lock");
1440 }
1441
1442 #[tokio::test]
1443 #[serial_test::serial]
1444 async fn list_parts_read_lock_respects_no_lock() {
1445 let store = new_multipart_lock_test_store().await;
1446 let object_lock = store
1447 .handle_new_ns_lock("bucket", "object")
1448 .await
1449 .expect("object namespace lock should be created");
1450 let _writer = object_lock
1451 .get_write_lock(Duration::from_secs(1))
1452 .await
1453 .expect("outer write lock should be acquired");
1454
1455 let result = temp_env::async_with_vars([(rustfs_config::ENV_OBJECT_LOCK_ACQUIRE_TIMEOUT, Some("1"))], async {
1456 store
1457 .acquire_list_parts_read_lock("bucket", "object", &ObjectOptions::default())
1458 .await
1459 })
1460 .await;
1461 let err = match result {
1462 Ok(_) => panic!("list parts read lock must wait behind an object writer"),
1463 Err(err) => err,
1464 };
1465 assert!(matches!(err, StorageError::Lock(rustfs_lock::LockError::Timeout { .. })));
1466
1467 let no_lock_guard = store
1468 .acquire_list_parts_read_lock(
1469 "bucket",
1470 "object",
1471 &ObjectOptions {
1472 no_lock: true,
1473 ..Default::default()
1474 },
1475 )
1476 .await
1477 .expect("no_lock list parts path should not acquire an object lock");
1478 assert!(no_lock_guard.is_none());
1479 }
1480}