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