Skip to main content

rustfs_ecstore/store/
multipart.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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        // A draining source must not hide a valid UploadID in an active target,
276        // while physical order within each phase preserves fail-closed errors.
277        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    /// Multipart lock order is bucket lifecycle, generation validation, then
337    /// object/upload locks in the selected set.
338    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            // TODO(backlog): return cached multipart listing when prefix is empty
446        }
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        // Each pool caps its own page at `max_uploads`, so the concatenation is
483        // unordered across pools and may exceed the global cap. Re-sort, re-cap,
484        // and derive the truncation markers so a bucket whose uploads span pools
485        // pages correctly instead of being silently reported complete.
486        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        // The full UploadPartCopy path still requires the higher S3/request layer to
640        // derive encryption, compression, and multipart checksum write semantics.
641        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        // TODO(backlog): defer DeleteUploadID to background for faster abort response
756
757        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                    //
768                    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        // Discover and lock uploads only after the target capacity gate is held.
868        // Return the guards so they remain alive through the final capacity save.
869        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                    // The target capacity gate makes the exact target proof,
935                    // upload absence proof, and pending-ledger decision one
936                    // critical section with cleanup finalize.
937                    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        // NewMultipart/UploadPart are staging only. Acquire and consume the
1085        // non-cloneable publication capability immediately before Complete,
1086        // then retain its guards until Complete has drained the commit path.
1087        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        // Data movement already owns the pool-meta write lease. Forward its
1117        // loss signal into SetDisks so commit fencing observes the same lease
1118        // without trying to reacquire the namespace.
1119        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
1142/// Merges per-pool `ListMultipartUploads` pages into a single globally paginated
1143/// page.
1144///
1145/// Each pool independently applies the `max_uploads` cap, so the concatenated
1146/// input can hold up to `pools * max_uploads` entries and is unordered across
1147/// pools. This re-sorts the union by `(key, upload_id)` — the order S3 clients
1148/// page through — caps it to `max_uploads`, and derives the truncation markers
1149/// from the first overflow element (used only as a probe, never returned) so a
1150/// bucket whose uploads span pools can be paged without loss or duplication.
1151fn 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    /// Models a single pool's `list_multipart_uploads`: returns uploads strictly
1240    /// after the `(key, upload_id)` marker in `(key, upload_id)` order, capped at
1241    /// `max_uploads` (mirroring the per-pool page cap).
1242    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        // Union of two pools, unordered and exceeding the global cap.
1262        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        // Uploads for the same bucket spread across two pools, together exceeding
1293        // the cap, so pagination must span multiple pages.
1294        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}