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_in(&self.ctx, bucket).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 if opts.data_movement && opts.version_id.is_some() {
534 let idx = self.select_data_movement_pool_idx(bucket, object, -1, &opts, false).await?;
535 if idx == opts.src_pool_idx {
536 return Err(StorageError::DataMovementOverwriteErr(
537 bucket.to_owned(),
538 object.to_owned(),
539 opts.version_id.clone().unwrap_or_default(),
540 ));
541 }
542 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
543 .await;
544 let res = self
545 .run_decommission_capacity_temporary_mutation(
546 idx,
547 DecommissionCapacityOwner::from_options(&opts),
548 None,
549 || async { self.pools[idx].new_multipart_upload(bucket, object, &opts).await },
550 )
551 .await?;
552 return Ok((res, idx, opts.expected_bucket_incarnation_id));
553 }
554
555 for (idx, pool) in self.pools.iter().enumerate() {
556 if self.is_suspended(idx).await || self.is_pool_rebalancing(idx).await {
557 continue;
558 }
559 let res = list_pool_multipart_uploads_for_incarnation(
560 pool,
561 bucket,
562 &MultipartUploadListRequest {
563 prefix: object.to_string(),
564 key_marker: None,
565 upload_id_marker: None,
566 delimiter: None,
567 max_uploads: MAX_UPLOADS_LIST,
568 expected_incarnation_id: opts.expected_bucket_incarnation_id,
569 },
570 )
571 .await?;
572
573 if !res.uploads.is_empty() {
574 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
575 .await;
576 let expected_bucket_incarnation_id = opts.expected_bucket_incarnation_id;
577 let lock_object = encode_dir_object(object);
578 let res = self
579 .run_external_decommission_capacity_object_mutation(
580 idx,
581 bucket,
582 &lock_object,
583 object,
584 opts,
585 |opts| async move { self.pools[idx].new_multipart_upload(bucket, object, &opts).await },
586 )
587 .await?;
588 return Ok((res, idx, expected_bucket_incarnation_id));
589 }
590 }
591 let idx = self.get_pool_idx(bucket, object, -1).await?;
592 if opts.data_movement && idx == opts.src_pool_idx {
593 return Err(StorageError::DataMovementOverwriteErr(
594 bucket.to_owned(),
595 object.to_owned(),
596 "".to_owned(),
597 ));
598 }
599
600 self.apply_decommission_target_mutation_fence(idx, object, &mut opts, mutation_fence)
601 .await;
602 let expected_bucket_incarnation_id = opts.expected_bucket_incarnation_id;
603 let res = if opts.data_movement {
604 self.run_decommission_capacity_temporary_mutation(
605 idx,
606 DecommissionCapacityOwner::from_options(&opts),
607 None,
608 || async { self.pools[idx].new_multipart_upload(bucket, object, &opts).await },
609 )
610 .await?
611 } else {
612 let lock_object = encode_dir_object(object);
613 self.run_external_decommission_capacity_object_mutation(idx, bucket, &lock_object, object, opts, |opts| async move {
614 self.pools[idx].new_multipart_upload(bucket, object, &opts).await
615 })
616 .await?
617 };
618 Ok((res, idx, expected_bucket_incarnation_id))
619 }
620
621 #[instrument(skip(self))]
622 #[allow(clippy::too_many_arguments)]
623 pub(super) async fn handle_copy_object_part(
624 &self,
625 src_bucket: &str,
626 src_object: &str,
627 _dst_bucket: &str,
628 _dst_object: &str,
629 _upload_id: &str,
630 _part_id: usize,
631 _start_offset: i64,
632 _length: i64,
633 _src_info: &ObjectInfo,
634 _src_opts: &ObjectOptions,
635 _dst_opts: &ObjectOptions,
636 ) -> Result<()> {
637 check_new_multipart_args(src_bucket, src_object)?;
638
639 Err(StorageError::NotImplemented)
642 }
643
644 #[instrument(skip(self, data))]
645 #[hotpath::measure(impl_type = "ECStore")]
646 pub(super) async fn handle_put_object_part(
647 &self,
648 bucket: &str,
649 object: &str,
650 upload_id: &str,
651 part_id: usize,
652 data: &mut PutObjReader,
653 opts: &ObjectOptions,
654 ) -> Result<PartInfo> {
655 check_put_object_part_args(bucket, object, upload_id)?;
656 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
657 if !self.single_pool() {
658 opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
659 }
660 let opts = &opts;
661
662 if self.single_pool() {
663 return self.pools[0]
664 .put_object_part(bucket, object, upload_id, part_id, data, opts)
665 .await;
666 }
667
668 let pool_idx = self.multipart_upload_pool_idx(bucket, object, upload_id, opts).await?;
669 self.pools[pool_idx]
670 .put_object_part(bucket, object, upload_id, part_id, data, opts)
671 .await
672 }
673
674 pub(crate) async fn put_object_part_for_data_movement(
675 &self,
676 target_pool_idx: usize,
677 bucket: &str,
678 object: &str,
679 upload_id: &str,
680 data: &mut PutObjReader,
681 opts: &ObjectOptions,
682 ) -> Result<PartInfo> {
683 let part_id = opts
684 .part_number
685 .ok_or_else(|| Error::other("targeted multipart upload requires a part number"))?;
686 check_put_object_part_args(bucket, object, upload_id)?;
687 if !opts.data_movement {
688 return Err(Error::other("targeted multipart upload requires data_movement options"));
689 }
690 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
691 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
692 let pool = self.pools.get(target_pool_idx).ok_or_else(|| {
693 Error::InvalidArgument("data-movement".to_string(), "target-pool".to_string(), target_pool_idx.to_string())
694 })?;
695 let expected_data_bytes = usize::try_from(data.size()).ok();
696 self.run_decommission_capacity_temporary_mutation_with_capacity_lease(
697 target_pool_idx,
698 DecommissionCapacityOwner::from_options(&opts),
699 expected_data_bytes,
700 |capacity_lease| async move {
701 if let Some(capacity_lease) = capacity_lease {
702 opts.add_namespace_lock_lost_signal(capacity_lease);
703 }
704 pool.put_object_part(bucket, object, upload_id, part_id, data, &opts).await
705 },
706 )
707 .await
708 }
709
710 #[instrument(skip(self))]
711 pub(super) async fn handle_get_multipart_info(
712 &self,
713 bucket: &str,
714 object: &str,
715 upload_id: &str,
716 opts: &ObjectOptions,
717 ) -> Result<MultipartInfo> {
718 check_list_parts_args(bucket, object, upload_id)?;
719 let (opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
720 let opts = &opts;
721 if self.single_pool() {
722 return self.pools[0].get_multipart_info(bucket, object, upload_id, opts).await;
723 }
724
725 for pool_idx in self.existing_multipart_pool_order().await {
726 let pool = &self.pools[pool_idx];
727
728 return match pool.get_multipart_info(bucket, object, upload_id, opts).await {
729 Ok(res) => Ok(res),
730 Err(err) => {
731 if is_err_invalid_upload_id(&err) {
732 continue;
733 }
734
735 Err(err)
736 }
737 };
738 }
739
740 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
741 }
742
743 #[instrument(skip(self))]
744 pub(super) async fn handle_abort_multipart_upload(
745 &self,
746 bucket: &str,
747 object: &str,
748 upload_id: &str,
749 opts: &ObjectOptions,
750 ) -> Result<()> {
751 check_abort_multipart_args(bucket, object, upload_id)?;
752 let (opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
753 let opts = &opts;
754
755 if self.single_pool() {
758 return self.pools[0].abort_multipart_upload(bucket, object, upload_id, opts).await;
759 }
760
761 for pool_idx in self.existing_multipart_pool_order().await {
762 let pool = &self.pools[pool_idx];
763
764 let err = match pool.abort_multipart_upload(bucket, object, upload_id, opts).await {
765 Ok(_) => return Ok(()),
766 Err(err) => {
767 if is_err_invalid_upload_id(&err) { None } else { Some(err) }
769 }
770 };
771
772 if let Some(er) = err {
773 return Err(er);
774 }
775 }
776
777 Err(StorageError::InvalidUploadID(bucket.to_owned(), object.to_owned(), upload_id.to_owned()))
778 }
779
780 pub(crate) async fn abort_multipart_upload_for_data_movement(
781 &self,
782 target_pool_idx: usize,
783 bucket: &str,
784 object: &str,
785 upload_id: &str,
786 opts: &ObjectOptions,
787 ) -> Result<()> {
788 let upload_identity = crate::data_movement::data_movement_upload_identity_from_options(opts);
789 self.abort_multipart_uploads_for_data_movement(
790 target_pool_idx,
791 bucket,
792 object,
793 &[upload_id.to_owned()],
794 &upload_identity,
795 opts,
796 )
797 .await
798 }
799
800 pub(crate) async fn reconcile_multipart_uploads_for_data_movement(
801 &self,
802 target_pool_idx: usize,
803 bucket: &str,
804 object: &str,
805 upload_identity: &str,
806 opts: &ObjectOptions,
807 ) -> Result<()> {
808 self.pools
809 .get(target_pool_idx)
810 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?;
811 let owner = DecommissionCapacityOwner::from_options(opts)
812 .ok_or_else(|| Error::other("data movement multipart cleanup is missing its capacity owner"))?;
813 if !self
814 .decommission_capacity_cleanup_target_indices(owner)
815 .await?
816 .contains(&target_pool_idx)
817 {
818 return Err(Error::DecommissionCapacityBlocked {
819 message: format!(
820 "data movement multipart cleanup target pool {target_pool_idx} is outside its capacity reservation"
821 ),
822 });
823 }
824 if !self
825 .has_decommission_capacity_temporary_mutation_state(target_pool_idx, owner)
826 .await
827 {
828 return Ok(());
829 }
830 #[cfg(test)]
831 {
832 *data_movement_multipart_discovery_counts()
833 .lock()
834 .unwrap_or_else(std::sync::PoisonError::into_inner)
835 .entry(self.id)
836 .or_default() += 1;
837 }
838 self.abort_multipart_uploads_for_data_movement(target_pool_idx, bucket, object, &[], upload_identity, opts)
839 .await
840 }
841
842 async fn abort_multipart_uploads_for_data_movement(
843 &self,
844 target_pool_idx: usize,
845 bucket: &str,
846 object: &str,
847 upload_ids: &[String],
848 expected_upload_identity: &str,
849 opts: &ObjectOptions,
850 ) -> Result<()> {
851 check_new_multipart_args(bucket, object)?;
852 for upload_id in upload_ids {
853 check_abort_multipart_args(bucket, object, upload_id)?;
854 }
855 if !opts.data_movement {
856 return Err(Error::other("targeted multipart abort requires data_movement options"));
857 }
858 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
859 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
860 let capacity_owner = DecommissionCapacityOwner::from_options(&opts);
861 let pool = self
862 .pools
863 .get(target_pool_idx)
864 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?;
865 opts.no_lock = true;
866 let set = pool.get_disks_by_key(object);
867 let (cleanup_decision_error, guards) = self
870 .run_decommission_capacity_temporary_release_with_capacity_lease(target_pool_idx, capacity_owner, |capacity_lease| {
871 let mut delete_opts = opts.clone();
872 let set = &set;
873 let pool = &pool;
874 async move {
875 if let Some(capacity_lease) = capacity_lease.as_ref() {
876 delete_opts.add_namespace_lock_lost_signal(Arc::clone(capacity_lease));
877 }
878 let mut candidate_upload_ids = upload_ids.to_vec();
879 candidate_upload_ids.extend(
880 set.data_movement_multipart_upload_ids(
881 bucket,
882 object,
883 delete_opts.expected_bucket_incarnation_id,
884 expected_upload_identity,
885 )
886 .await?,
887 );
888 candidate_upload_ids.sort_unstable();
889 candidate_upload_ids.dedup();
890
891 let mut guards = Vec::with_capacity(candidate_upload_ids.len());
892 for upload_id in &candidate_upload_ids {
893 match set
894 .lock_data_movement_multipart_abort(
895 bucket,
896 object,
897 upload_id,
898 Some(expected_upload_identity),
899 &delete_opts,
900 )
901 .await
902 {
903 Ok(Some(guard)) => {
904 guard.add_namespace_lock_fence(&mut delete_opts);
905 guards.push(guard);
906 }
907 Ok(None) => {}
908 Err(err) => return Err(err),
909 }
910 }
911 for guard in &guards {
912 match guard.delete(set, bucket, object, &delete_opts).await {
913 Ok(()) => {}
914 Err(err) if is_err_invalid_upload_id(&err) => {}
915 Err(err) => return Err(err),
916 }
917 }
918
919 if !set
920 .data_movement_multipart_upload_ids(
921 bucket,
922 object,
923 delete_opts.expected_bucket_incarnation_id,
924 expected_upload_identity,
925 )
926 .await?
927 .is_empty()
928 {
929 return Err(Error::DecommissionCapacityBlocked {
930 message: "multipart cleanup could not prove the exact staged uploads are absent".to_string(),
931 });
932 }
933
934 let (clear_pending, cleanup_decision_error) = if capacity_owner.is_some() {
938 let mut lookup_opts = ObjectOptions {
939 versioned: delete_opts.versioned,
940 version_suspended: delete_opts.version_suspended,
941 version_id: delete_opts.version_id.clone(),
942 metadata_chg: delete_opts.version_id.is_some(),
943 no_lock: true,
944 ..Default::default()
945 };
946 if let Some(capacity_lease) = capacity_lease {
947 lookup_opts.add_namespace_lock_lost_signal(capacity_lease);
948 }
949 let target = match pool.get_object_info(bucket, object, &lookup_opts).await {
950 Ok(target) => Some(target),
951 Err(err) if is_err_object_not_found(&err) || is_err_version_not_found(&err) => None,
952 Err(err) => return Err(err),
953 };
954 match decommission_multipart_target_clear_pending(&delete_opts, target.as_ref()) {
955 Ok(clear_pending) => (clear_pending, None),
956 Err(err) => (false, Some(err)),
957 }
958 } else {
959 (true, None)
960 };
961 Ok(((cleanup_decision_error, guards), clear_pending))
962 }
963 })
964 .await?;
965 drop(guards);
966 if let Some(err) = cleanup_decision_error {
967 return Err(err);
968 }
969 Ok(())
970 }
971
972 #[instrument(skip(self))]
973 pub(super) async fn handle_complete_multipart_upload(
974 self: Arc<Self>,
975 bucket: &str,
976 object: &str,
977 upload_id: &str,
978 uploaded_parts: Vec<CompletePart>,
979 opts: &ObjectOptions,
980 ) -> Result<ObjectInfo> {
981 check_complete_multipart_args(bucket, object, upload_id)?;
982 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
983 if !self.single_pool() {
984 opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
985 }
986 let opts = &opts;
987
988 if self.single_pool() {
989 return self.pools[0]
990 .clone()
991 .complete_multipart_upload(bucket, object, upload_id, uploaded_parts, opts)
992 .await;
993 }
994
995 let pool_idx = self.multipart_upload_pool_idx(bucket, object, upload_id, opts).await?;
996 let pool = self.pools[pool_idx].clone();
997 pool.complete_multipart_upload(bucket, object, upload_id, uploaded_parts, opts)
998 .await
999 }
1000
1001 #[cfg(all(test, feature = "test-util"))]
1002 pub(crate) async fn complete_multipart_upload_for_data_movement(
1003 self: Arc<Self>,
1004 target: (usize, Option<&ObjectLockDiagGuard>),
1005 bucket: &str,
1006 object: &str,
1007 upload_id: &str,
1008 uploaded_parts: Vec<CompletePart>,
1009 opts: &ObjectOptions,
1010 ) -> Result<ObjectInfo> {
1011 self.complete_multipart_upload_for_data_movement_inner(target, bucket, object, upload_id, uploaded_parts, opts, None)
1012 .await
1013 }
1014
1015 #[allow(clippy::too_many_arguments)]
1016 pub(crate) async fn complete_multipart_upload_for_data_movement_with_publication_fence(
1017 self: Arc<Self>,
1018 target_pool_idx: usize,
1019 bucket: &str,
1020 object: &str,
1021 upload_id: &str,
1022 uploaded_parts: Vec<CompletePart>,
1023 opts: &ObjectOptions,
1024 publication_fence: RemoteTuplePublicationFence,
1025 ) -> Result<ObjectInfo> {
1026 self.complete_multipart_upload_for_data_movement_inner(
1027 (target_pool_idx, None),
1028 bucket,
1029 object,
1030 upload_id,
1031 uploaded_parts,
1032 opts,
1033 Some(publication_fence),
1034 )
1035 .await
1036 }
1037
1038 #[allow(clippy::too_many_arguments)]
1039 async fn complete_multipart_upload_for_data_movement_inner(
1040 self: Arc<Self>,
1041 target: (usize, Option<&ObjectLockDiagGuard>),
1042 bucket: &str,
1043 object: &str,
1044 upload_id: &str,
1045 uploaded_parts: Vec<CompletePart>,
1046 opts: &ObjectOptions,
1047 publication_fence: Option<RemoteTuplePublicationFence>,
1048 ) -> Result<ObjectInfo> {
1049 let (target_pool_idx, mutation_fence) = target;
1050 check_complete_multipart_args(bucket, object, upload_id)?;
1051 if !opts.data_movement {
1052 return Err(Error::other("targeted multipart completion requires data_movement options"));
1053 }
1054 let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
1055 ensure_decommission_capacity_mutation_id(bucket, object, &mut opts);
1056 if opts.overwrites_existing_version() && !is_meta_bucketname(bucket) {
1057 let expected_incarnation_id = opts
1058 .expected_bucket_incarnation_id
1059 .ok_or_else(|| Error::other("data movement completion is missing its bucket incarnation"))?;
1060 let lifecycle_fence = opts
1061 .bucket_lifecycle_lock_fence
1062 .as_ref()
1063 .ok_or_else(|| Error::other("data movement completion is missing its bucket lifecycle fence"))?;
1064 let snapshot = match opts.object_lock_config_snapshot.as_ref() {
1065 Some(snapshot) => Arc::clone(snapshot),
1066 None => {
1067 self.object_lock_config_snapshot_under_lifecycle_fence(bucket, lifecycle_fence)
1068 .await?
1069 }
1070 };
1071 if !snapshot.is_valid_for_destructive_put(self.id, bucket, expected_incarnation_id) {
1072 return Err(Error::other(
1073 "data movement Object Lock snapshot does not match the target bucket generation",
1074 ));
1075 }
1076 snapshot.add_lock_fences(&mut opts);
1077 opts.object_lock_config_snapshot = Some(snapshot);
1078 }
1079 let fixed_read_anchor = publication_fence
1080 .as_ref()
1081 .and_then(RemoteTuplePublicationFence::fixed_read_anchor_guard);
1082 self.apply_decommission_target_mutation_fence(target_pool_idx, object, &mut opts, mutation_fence.or(fixed_read_anchor))
1083 .await;
1084 let publication_object = encode_dir_object(object);
1088 let publication_guard = match publication_fence {
1089 Some(publication_fence) => {
1090 let guard = publication_fence
1091 .into_commit_guard(target_pool_idx, bucket, &publication_object)
1092 .await?;
1093 guard.add_namespace_lock_fence(&mut opts);
1094 opts.no_lock = true;
1095 Some(guard)
1096 }
1097 None => {
1098 if rustfs_utils::http::metadata_compat::contains_key_str(
1099 &opts.user_defined,
1100 rustfs_utils::http::SUFFIX_TRANSITION_STATUS,
1101 ) {
1102 return Err(Error::other(
1103 "data movement multipart completion cannot publish transition ownership without a publication capability",
1104 ));
1105 }
1106 None
1107 }
1108 };
1109 #[cfg(test)]
1110 pause_data_movement_multipart_before_selected_completion(bucket).await;
1111 let pool = self
1112 .pools
1113 .get(target_pool_idx)
1114 .ok_or_else(|| Error::other(format!("data movement target pool {target_pool_idx} is out of range")))?
1115 .clone();
1116 let result = self
1120 .run_decommission_capacity_admitted_mutation_with_capacity_lease(
1121 target_pool_idx,
1122 DecommissionCapacityOwner::from_options(&opts),
1123 opts.capacity_expected_data_bytes(),
1124 |capacity_lease| async move {
1125 if let Some(capacity_lease) = capacity_lease {
1126 opts.add_namespace_lock_lost_signal(capacity_lease);
1127 }
1128 pool.complete_multipart_upload(bucket, object, upload_id, uploaded_parts, &opts)
1129 .await
1130 },
1131 )
1132 .await;
1133 drop(publication_guard);
1134 let result = enqueue_transition_after_write(result, LcEventSrc::S3CompleteMultipartUpload).await;
1135 if result.is_ok() {
1136 list_objects::observe_list_objects_mutation(self.as_ref(), bucket).await;
1137 }
1138 result
1139 }
1140}
1141
1142fn merge_multipart_upload_pages(
1152 uploads: Vec<MultipartInfo>,
1153 common_prefixes: Vec<String>,
1154 max_uploads: usize,
1155 source_truncated: bool,
1156) -> crate::multipart_listing::MultipartListingPage {
1157 paginate_multipart_listing(uploads, common_prefixes, None, None, max_uploads, source_truncated)
1158}
1159
1160#[cfg(test)]
1161mod tests {
1162 use super::*;
1163 use crate::layout::{
1164 endpoints::{Endpoints, PoolEndpoints},
1165 format::FormatV3,
1166 };
1167 use std::time::Duration;
1168
1169 fn mp(object: &str, upload_id: &str) -> MultipartInfo {
1170 MultipartInfo {
1171 bucket: "bucket".to_string(),
1172 object: object.to_string(),
1173 upload_id: upload_id.to_string(),
1174 initiated: None,
1175 ..Default::default()
1176 }
1177 }
1178
1179 #[test]
1180 fn decommission_multipart_cleanup_requires_exact_target_evidence() {
1181 let version_id = Uuid::new_v4();
1182 let mod_time = time::OffsetDateTime::UNIX_EPOCH + time::Duration::seconds(7);
1183 let opts = ObjectOptions {
1184 versioned: true,
1185 version_id: Some(version_id.to_string()),
1186 mod_time: Some(mod_time),
1187 ..Default::default()
1188 };
1189
1190 assert!(
1191 decommission_multipart_target_clear_pending(&opts, None)
1192 .expect("an exact target miss should authorize pending cleanup")
1193 );
1194
1195 let mut metadata = HashMap::new();
1196 rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_DATA_MOVED, "true".to_string());
1197 rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_DATA_MOVED_TAGS, "v1:".to_string());
1198 let owned_target = ObjectInfo {
1199 version_id: Some(version_id),
1200 mod_time: Some(mod_time),
1201 user_defined: Arc::new(metadata),
1202 ..Default::default()
1203 };
1204 assert!(
1205 !decommission_multipart_target_clear_pending(&opts, Some(&owned_target))
1206 .expect("an exact owned target should preserve pending capacity")
1207 );
1208
1209 let missing_identity = ObjectOptions {
1210 mod_time: None,
1211 ..opts.clone()
1212 };
1213 assert!(matches!(
1214 decommission_multipart_target_clear_pending(&missing_identity, None),
1215 Err(Error::DecommissionCapacityBlocked { .. })
1216 ));
1217
1218 let mismatched_target = ObjectInfo {
1219 version_id: Some(Uuid::new_v4()),
1220 mod_time: Some(mod_time),
1221 ..Default::default()
1222 };
1223 assert!(matches!(
1224 decommission_multipart_target_clear_pending(&opts, Some(&mismatched_target)),
1225 Err(Error::DecommissionCapacityBlocked { .. })
1226 ));
1227
1228 let unowned_target = ObjectInfo {
1229 version_id: Some(version_id),
1230 mod_time: Some(mod_time),
1231 ..Default::default()
1232 };
1233 assert!(matches!(
1234 decommission_multipart_target_clear_pending(&opts, Some(&unowned_target)),
1235 Err(Error::DecommissionCapacityBlocked { .. })
1236 ));
1237 }
1238
1239 fn pool_query(
1243 pool: &[MultipartInfo],
1244 key_marker: Option<&str>,
1245 upload_id_marker: Option<&str>,
1246 max_uploads: usize,
1247 ) -> Vec<MultipartInfo> {
1248 pool.iter()
1249 .filter(|u| match (key_marker, upload_id_marker) {
1250 (Some(k), Some(uid)) => (u.object.as_str(), u.upload_id.as_str()) > (k, uid),
1251 (Some(k), None) => u.object.as_str() > k,
1252 _ => true,
1253 })
1254 .take(max_uploads)
1255 .cloned()
1256 .collect()
1257 }
1258
1259 #[test]
1260 fn merge_multipart_upload_pages_sorts_and_caps_across_pools() {
1261 let uploads = vec![mp("b", "u1"), mp("a", "u2"), mp("a", "u1"), mp("c", "u1"), mp("b", "u2")];
1263
1264 let page = merge_multipart_upload_pages(uploads, Vec::new(), 3, false);
1265
1266 assert!(page.is_truncated);
1267 assert_eq!(page.uploads.len(), 3);
1268 let ordered: Vec<(&str, &str)> = page
1269 .uploads
1270 .iter()
1271 .map(|u| (u.object.as_str(), u.upload_id.as_str()))
1272 .collect();
1273 assert_eq!(ordered, vec![("a", "u1"), ("a", "u2"), ("b", "u1")]);
1274 assert_eq!(page.next_key_marker.as_deref(), Some("b"));
1275 assert_eq!(page.next_upload_id_marker.as_deref(), Some("u1"));
1276 }
1277
1278 #[test]
1279 fn merge_multipart_upload_pages_reports_complete_within_cap() {
1280 let uploads = vec![mp("b", "u1"), mp("a", "u1")];
1281
1282 let page = merge_multipart_upload_pages(uploads, Vec::new(), 3, false);
1283
1284 assert_eq!(page.uploads.len(), 2);
1285 assert!(!page.is_truncated);
1286 assert!(page.next_key_marker.is_none());
1287 assert!(page.next_upload_id_marker.is_none());
1288 }
1289
1290 #[test]
1291 fn merge_multipart_upload_pages_paginates_across_pools_without_loss() {
1292 let pool0 = vec![mp("a", "u1"), mp("a", "u3"), mp("c", "u1"), mp("e", "u1")];
1295 let pool1 = vec![mp("a", "u2"), mp("b", "u1"), mp("d", "u1"), mp("f", "u1")];
1296
1297 let mut expected: Vec<(String, String)> = pool0
1298 .iter()
1299 .chain(pool1.iter())
1300 .map(|u| (u.object.clone(), u.upload_id.clone()))
1301 .collect();
1302 expected.sort();
1303
1304 let max_uploads = 3;
1305 let mut key_marker: Option<String> = None;
1306 let mut upload_id_marker: Option<String> = None;
1307 let mut collected: Vec<(String, String)> = Vec::new();
1308
1309 for _ in 0..16 {
1310 let mut merged = Vec::new();
1311 for pool in [&pool0, &pool1] {
1312 merged.extend(pool_query(pool, key_marker.as_deref(), upload_id_marker.as_deref(), max_uploads));
1313 }
1314
1315 let page = merge_multipart_upload_pages(merged, Vec::new(), max_uploads, false);
1316 assert!(page.uploads.len() <= max_uploads);
1317 collected.extend(page.uploads.iter().map(|u| (u.object.clone(), u.upload_id.clone())));
1318
1319 if !page.is_truncated {
1320 break;
1321 }
1322 key_marker = page.next_key_marker;
1323 upload_id_marker = page.next_upload_id_marker;
1324 }
1325
1326 assert_eq!(collected, expected, "pagination must return every upload exactly once, in sorted order");
1327 let mut deduped = collected.clone();
1328 deduped.dedup();
1329 assert_eq!(deduped.len(), collected.len(), "pagination must not duplicate uploads");
1330 }
1331
1332 #[test]
1333 fn merge_multipart_upload_pages_includes_common_prefixes() {
1334 let page = merge_multipart_upload_pages(
1335 vec![mp("logs/root.bin", "u1")],
1336 vec!["logs/2026/".to_string(), "logs/2025/".to_string()],
1337 2,
1338 false,
1339 );
1340
1341 assert!(page.is_truncated);
1342 assert!(page.uploads.is_empty());
1343 assert_eq!(page.common_prefixes, vec!["logs/2025/", "logs/2026/"]);
1344 assert_eq!(page.next_key_marker.as_deref(), Some("logs/2026/"));
1345 assert!(page.next_upload_id_marker.is_none());
1346 }
1347
1348 #[test]
1349 fn merge_multipart_upload_pages_preserves_pool_truncation() {
1350 let page = merge_multipart_upload_pages(vec![mp("a", "u1")], Vec::new(), 1, true);
1351
1352 assert!(page.is_truncated);
1353 assert_eq!(page.next_key_marker.as_deref(), Some("a"));
1354 assert_eq!(page.next_upload_id_marker.as_deref(), Some("u1"));
1355 }
1356
1357 async fn new_multipart_lock_test_store() -> ECStore {
1358 let format = FormatV3::new(1, 2);
1359 let endpoints = vec![
1360 Endpoint::try_from("http://127.0.0.1:9000/data0").expect("first endpoint should parse"),
1361 Endpoint::try_from("http://127.0.0.1:9001/data1").expect("second endpoint should parse"),
1362 ];
1363 let pool_endpoints = PoolEndpoints {
1364 legacy: false,
1365 set_count: 1,
1366 drives_per_set: 2,
1367 endpoints: Endpoints::from(endpoints),
1368 cmd_line: "multipart-list-parts-lock-test".to_string(),
1369 platform: "test".to_string(),
1370 };
1371 let endpoint_pools = EndpointServerPools::from(vec![pool_endpoints.clone()]);
1372 let sets = Sets::new(vec![None, None], &pool_endpoints, &format, 0, 1)
1373 .await
1374 .expect("test sets should be created with empty disks");
1375
1376 ECStore {
1377 id: Uuid::new_v4(),
1378 disk_map: HashMap::new(),
1379 pools: vec![sets],
1380 peer_sys: S3PeerSys::new(&endpoint_pools),
1381 pool_meta: RwLock::new(PoolMeta::default()),
1382 rebalance_meta: RwLock::new(None),
1383 decommission_cancelers: RwLock::new(Vec::new()),
1384 start_gate: Mutex::new(()),
1385 pool_meta_save_gate: Mutex::default(),
1386 ctx: crate::runtime::instance::bootstrap_ctx(),
1387 bucket_fence_registry: std::sync::Arc::default(),
1388 }
1389 }
1390
1391 #[tokio::test]
1392 async fn list_parts_read_lock_blocks_object_writer_until_released() {
1393 let store = new_multipart_lock_test_store().await;
1394 let read_guard = store
1395 .acquire_list_parts_read_lock("bucket", "object", &ObjectOptions::default())
1396 .await
1397 .expect("list parts read lock should be acquired")
1398 .expect("default options should acquire a read lock");
1399
1400 let object_lock = store
1401 .handle_new_ns_lock("bucket", "object")
1402 .await
1403 .expect("object namespace lock should be created");
1404 let err = object_lock
1405 .get_write_lock(Duration::from_millis(20))
1406 .await
1407 .expect_err("list parts read lock should block object writers");
1408 assert!(matches!(err, rustfs_lock::LockError::Timeout { .. }));
1409
1410 drop(read_guard);
1411 object_lock
1412 .get_write_lock(Duration::from_secs(1))
1413 .await
1414 .expect("object writer should proceed after list parts releases the read lock");
1415 }
1416
1417 #[tokio::test]
1418 #[serial_test::serial]
1419 async fn list_parts_read_lock_respects_no_lock() {
1420 let store = new_multipart_lock_test_store().await;
1421 let object_lock = store
1422 .handle_new_ns_lock("bucket", "object")
1423 .await
1424 .expect("object namespace lock should be created");
1425 let _writer = object_lock
1426 .get_write_lock(Duration::from_secs(1))
1427 .await
1428 .expect("outer write lock should be acquired");
1429
1430 let result = temp_env::async_with_vars([(rustfs_config::ENV_OBJECT_LOCK_ACQUIRE_TIMEOUT, Some("1"))], async {
1431 store
1432 .acquire_list_parts_read_lock("bucket", "object", &ObjectOptions::default())
1433 .await
1434 })
1435 .await;
1436 let err = match result {
1437 Ok(_) => panic!("list parts read lock must wait behind an object writer"),
1438 Err(err) => err,
1439 };
1440 assert!(matches!(err, StorageError::Lock(rustfs_lock::LockError::Timeout { .. })));
1441
1442 let no_lock_guard = store
1443 .acquire_list_parts_read_lock(
1444 "bucket",
1445 "object",
1446 &ObjectOptions {
1447 no_lock: true,
1448 ..Default::default()
1449 },
1450 )
1451 .await
1452 .expect("no_lock list parts path should not acquire an object lock");
1453 assert!(no_lock_guard.is_none());
1454 }
1455}