Skip to main content

rustfs_ecstore/store/
peer.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::bucket::utils::has_bad_path_component;
17use crate::disk::error::{DiskError, Result as DiskResult};
18use crate::disk::{DeleteOptions, Disk, RenameDataGuards, RenameDataResp};
19use crate::runtime::instance::{InstanceContext, NamespaceCommitGuard};
20use crate::runtime::sources as runtime_sources;
21use tracing::{debug, error};
22
23const LOG_COMPONENT_ECSTORE: &str = "ecstore";
24const LOG_SUBSYSTEM_DISK_STARTUP: &str = "disk_startup";
25const EVENT_LOCAL_DISK_ID_PREWARM_SKIPPED: &str = "local_disk_id_prewarm_skipped";
26const EVENT_LOCK_CLIENT_INITIALIZATION_FAILED: &str = "lock_client_initialization_failed";
27
28/// An instance-bound capability for internal writes before ECStore/IAM startup.
29/// Its private context and volume checks cannot be replaced by a caller guard.
30#[derive(Clone)]
31pub struct BootstrapLocalTarget {
32    ctx: Arc<InstanceContext>,
33}
34
35impl BootstrapLocalTarget {
36    pub fn new(ctx: Arc<InstanceContext>) -> Self {
37        Self { ctx }
38    }
39
40    pub fn is_for_store(&self, store: &ECStore) -> bool {
41        Arc::ptr_eq(&self.ctx, &store.ctx)
42    }
43
44    pub async fn rename_local_data(
45        &self,
46        disk_ref: &str,
47        source: (&str, &str),
48        fi: &FileInfo,
49        destination: (&str, &str),
50        scanner_token: Option<Uuid>,
51    ) -> DiskResult<RenameDataResp> {
52        if scanner_token.is_some() {
53            return Err(DiskError::other("bootstrap rename cannot use a scanner publication lease"));
54        }
55        validate_bootstrap_volume(source.0)?;
56        validate_bootstrap_volume(destination.0)?;
57        rename_local_data_with_ctx(&self.ctx, disk_ref, source, fi, destination, RenameDataGuards::default()).await
58    }
59
60    pub async fn undo_local_write(
61        &self,
62        disk_ref: &str,
63        volume: &str,
64        path: &str,
65        fi: FileInfo,
66        opts: DeleteOptions,
67    ) -> DiskResult<()> {
68        validate_bootstrap_volume(volume)?;
69        undo_local_write_with_ctx(&self.ctx, disk_ref, volume, path, fi, opts).await
70    }
71}
72
73fn validate_bootstrap_volume(volume: &str) -> DiskResult<()> {
74    // Prefix membership alone permits aliases such as .rustfs.sys/../bucket.
75    // Validate both raw rename volumes before any disk lookup or admission.
76    if has_bad_path_component(volume) || !is_meta_bucketname(volume) {
77        return Err(DiskError::FileAccessDenied);
78    }
79    Ok(())
80}
81
82impl ECStore {
83    pub async fn write_local_metadata_at_incarnation(
84        self: &Arc<Self>,
85        disk_ref: &str,
86        target: (&str, &str),
87        fi: FileInfo,
88        expected: Uuid,
89    ) -> DiskResult<()> {
90        let disk_ref = disk_ref.to_owned();
91        let path = target.1.to_owned();
92        self.run_bucket_heal_at_incarnation(target.0, expected, &Default::default(), move |store, volume, _| async move {
93            let (disk, id) = local_disk_candidate(&store.ctx, &disk_ref).await?;
94            let _owner = admit_local_disk(&store.ctx, &disk, id, true).await?;
95            disk.write_metadata("", &volume, &path, fi).await.map_err(Into::into)
96        })
97        .await
98        .map_err(|error| DiskError::other(error.to_string()))
99    }
100
101    pub async fn delete_local_path_at_incarnation(
102        self: &Arc<Self>,
103        disk_ref: &str,
104        target: (&str, &str),
105        opts: DeleteOptions,
106        expected: Uuid,
107    ) -> DiskResult<()> {
108        let disk_ref = disk_ref.to_owned();
109        let path = target.1.to_owned();
110        self.run_bucket_heal_at_incarnation(target.0, expected, &Default::default(), move |store, volume, _| async move {
111            let (disk, id) = local_disk_candidate(&store.ctx, &disk_ref).await?;
112            let owner = admit_local_disk(&store.ctx, &disk, id, true).await?;
113            let scope = super::bucket_heal_scope(&volume).ok_or_else(|| StorageError::other("missing bucket heal scope"))?;
114            scope.check()?;
115            disk.delete_with_namespace_owner(&volume, &path, opts, Some(Arc::new((scope, owner))))
116                .await
117                .map_err(Into::into)
118        })
119        .await
120        .map_err(|error| DiskError::other(error.to_string()))
121    }
122
123    pub async fn delete_local_version_at_incarnation(
124        &self,
125        disk_ref: &str,
126        target: (&str, &str),
127        fi: FileInfo,
128        force_del_marker: bool,
129        opts: DeleteOptions,
130        expected: Uuid,
131    ) -> DiskResult<()> {
132        if expected.is_nil() || opts.undo_write || self.ctx.lock_manager().is_disabled() {
133            return Err(DiskError::other("invalid incarnation-bound heal deletion"));
134        }
135        let fence = Arc::new(
136            self.acquire_bucket_incarnation_fence(target.0, expected)
137                .await
138                .map_err(|error| DiskError::other(error.to_string()))?,
139        );
140        let (disk, id) = local_disk_candidate(&self.ctx, disk_ref).await?;
141        let owner = admit_local_disk(&self.ctx, &disk, id, true).await?;
142        if fence.is_lock_lost() {
143            return Err(DiskError::other("bucket heal incarnation fence was lost"));
144        }
145        disk.delete_version_with_namespace_owner(target.0, target.1, fi, force_del_marker, opts, Some(Arc::new((fence, owner))))
146            .await
147    }
148
149    /// Target-side admission for an incarnation-bound heal rename. The physical
150    /// namespace operations retain the lifecycle owner after RPC cancellation.
151    pub async fn rename_local_data_at_incarnation(
152        &self,
153        disk_ref: &str,
154        source: (&str, &str),
155        fi: &FileInfo,
156        destination: (&str, &str),
157        expected: Uuid,
158    ) -> DiskResult<RenameDataResp> {
159        if expected.is_nil() || self.ctx.lock_manager().is_disabled() {
160            return Err(DiskError::other(
161                "incarnation-bound rename requires namespace locking and a non-nil identity",
162            ));
163        }
164        let guard = Arc::new(
165            self.acquire_bucket_incarnation_fence(destination.0, expected)
166                .await
167                .map_err(|error| DiskError::other(error.to_string()))?,
168        );
169        if guard.is_lock_lost() {
170            return Err(DiskError::other("bucket heal incarnation fence was lost"));
171        }
172        rename_local_data_with_ctx(
173            &self.ctx,
174            disk_ref,
175            source,
176            fi,
177            destination,
178            RenameDataGuards {
179                external_guard: Some(guard),
180                ..Default::default()
181            },
182        )
183        .await
184    }
185
186    /// Execute on this instance's active local disk through the physical owner.
187    pub async fn rename_local_data(
188        &self,
189        disk_ref: &str,
190        source: (&str, &str),
191        fi: &FileInfo,
192        destination: (&str, &str),
193        scanner_token: Option<Uuid>,
194    ) -> DiskResult<RenameDataResp> {
195        let external_guard: Option<Arc<dyn Send + Sync>> = if let Some(token) = scanner_token {
196            Some(Arc::new(
197                self.acquire_scanner_publication_lease_guard(token)
198                    .await
199                    .map_err(|err| DiskError::other(err.to_string()))?,
200            ))
201        } else {
202            None
203        };
204        rename_local_data_with_ctx(
205            &self.ctx,
206            disk_ref,
207            source,
208            fi,
209            destination,
210            RenameDataGuards {
211                scanner_publication_lease_token: scanner_token,
212                external_guard,
213                namespace_owner: None,
214            },
215        )
216        .await
217    }
218
219    pub async fn undo_local_write(
220        &self,
221        disk_ref: &str,
222        volume: &str,
223        path: &str,
224        fi: FileInfo,
225        opts: DeleteOptions,
226    ) -> DiskResult<()> {
227        undo_local_write_with_ctx(&self.ctx, disk_ref, volume, path, fi, opts).await
228    }
229}
230
231// The optional ID is a cold lookup to cache only after final admission.
232async fn local_disk_candidate(ctx: &Arc<InstanceContext>, disk_ref: &str) -> DiskResult<(DiskStore, Option<Uuid>)> {
233    let map = ctx.local_disk_map();
234    if let Some(disk) = map.read().await.get(disk_ref).and_then(Option::as_ref).cloned() {
235        return Ok((disk, None));
236    }
237    let disk_id = Uuid::parse_str(disk_ref).map_err(|_| DiskError::DiskNotFound)?;
238    let cached_path = ctx.local_disk_id_map().read().await.get(&disk_id).cloned();
239    if let Some(path) = cached_path {
240        let cached_disk = map.read().await.get(&path).and_then(Option::as_ref).cloned();
241        if let Some(disk) = cached_disk
242            && matches!(disk.as_ref(), Disk::Local(_))
243            && disk.get_disk_id().await? == Some(disk_id)
244        {
245            return Ok((disk, None));
246        }
247    }
248    let disks: Vec<_> = map.read().await.values().filter_map(Clone::clone).collect();
249    // Disk identity may perform format I/O. No registry guard spans this await.
250    for disk in disks {
251        if matches!(disk.as_ref(), Disk::Local(_)) && disk.get_disk_id().await.ok().flatten() == Some(disk_id) {
252            return Ok((disk, Some(disk_id)));
253        }
254    }
255    Err(DiskError::DiskNotFound)
256}
257
258async fn admit_local_disk(
259    ctx: &Arc<InstanceContext>,
260    disk: &DiskStore,
261    disk_id: Option<Uuid>,
262    mutates_namespace: bool,
263) -> DiskResult<Option<Arc<NamespaceCommitGuard>>> {
264    if !matches!(disk.as_ref(), Disk::Local(_)) {
265        return Err(DiskError::DiskNotFound);
266    }
267    let map = ctx.local_disk_map();
268    let active = map.read().await;
269    if !active
270        .get(&disk.endpoint().to_string())
271        .and_then(Option::as_ref)
272        .is_some_and(|current| Arc::ptr_eq(current, disk))
273    {
274        return Err(DiskError::DiskNotFound);
275    }
276    // Preserve registry -> ID-cache lock order; no filesystem I/O under either.
277    if let Some(disk_id) = disk_id {
278        ctx.local_disk_id_map()
279            .write()
280            .await
281            .insert(disk_id, disk.endpoint().to_string());
282    }
283    // Admission linearizes under the registry read: replacement/quarantine
284    // before this point rejects; later changes do not revoke physical I/O.
285    Ok(mutates_namespace.then(|| ctx.begin_namespace_commit()))
286}
287
288async fn rename_local_data_with_ctx(
289    ctx: &Arc<InstanceContext>,
290    disk_ref: &str,
291    source: (&str, &str),
292    fi: &FileInfo,
293    destination: (&str, &str),
294    mut guards: RenameDataGuards,
295) -> DiskResult<RenameDataResp> {
296    let (disk, disk_id) = local_disk_candidate(ctx, disk_ref).await?;
297    let mutates_namespace = !is_meta_bucketname(source.0) || !is_meta_bucketname(destination.0);
298    let owner = admit_local_disk(ctx, &disk, disk_id, mutates_namespace).await?;
299    guards.namespace_owner = owner.as_ref().map(|owner| owner.clone() as Arc<dyn Send + Sync>);
300    let result = disk
301        .rename_data_borrowed_with_fence_observed(source.0, source.1, fi, destination.0, destination.1, guards)
302        .await
303        .result;
304    drop(owner);
305    result
306}
307
308async fn undo_local_write_with_ctx(
309    ctx: &Arc<InstanceContext>,
310    disk_ref: &str,
311    volume: &str,
312    path: &str,
313    fi: FileInfo,
314    opts: DeleteOptions,
315) -> DiskResult<()> {
316    if !opts.undo_write {
317        return Err(DiskError::other("target undo requires undo_write"));
318    }
319    let (disk, disk_id) = local_disk_candidate(ctx, disk_ref).await?;
320    let owner = admit_local_disk(ctx, &disk, disk_id, !is_meta_bucketname(volume)).await?;
321    let physical_owner = owner.as_ref().map(|owner| owner.clone() as Arc<dyn Send + Sync>);
322    let result = disk
323        .undo_write_with_namespace_owner(volume, path, fi, opts, physical_owner)
324        .await;
325    drop(owner);
326    result
327}
328
329async fn remember_local_disk_id(disk: &DiskStore) -> Option<Uuid> {
330    remember_local_disk_id_with_instance_ctx(&crate::runtime::global::current_ctx(), disk).await
331}
332
333async fn remember_local_disk_id_with_instance_ctx(instance_ctx: &Arc<InstanceContext>, disk: &DiskStore) -> Option<Uuid> {
334    let disk_id = disk.get_disk_id().await.ok().flatten()?;
335    record_local_disk_id_if_active(instance_ctx, disk, disk_id)
336        .await
337        .then_some(disk_id)
338}
339
340async fn record_local_disk_id_if_active(instance_ctx: &Arc<InstanceContext>, disk: &DiskStore, disk_id: Uuid) -> bool {
341    let endpoint = disk.endpoint().to_string();
342    let local_disk_map = instance_ctx.local_disk_map();
343    let local_disks = local_disk_map.read().await;
344    let Some(active_disk) = local_disks.get(&endpoint).and_then(Option::as_ref) else {
345        return false;
346    };
347    if !Arc::ptr_eq(active_disk, disk) {
348        return false;
349    }
350
351    // Lock order is local_disk_map -> local_disk_id_map so quarantine is the
352    // linearization point for rejecting an in-flight stale disk snapshot.
353    instance_ctx.local_disk_id_map().write().await.insert(disk_id, endpoint);
354    true
355}
356
357pub async fn find_local_disk(disk_path: &str) -> Option<DiskStore> {
358    runtime_sources::local_disk_by_path(disk_path).await
359}
360
361pub async fn find_local_disk_by_ref(disk_ref: &str) -> Option<DiskStore> {
362    if let Some(disk) = find_local_disk(disk_ref).await {
363        let _ = remember_local_disk_id(&disk).await;
364        return Some(disk);
365    }
366
367    let Ok(disk_id) = Uuid::parse_str(disk_ref) else {
368        return None;
369    };
370
371    if let Some(disk_path) = runtime_sources::local_disk_path_by_id(&disk_id).await
372        && let Some(disk) = find_local_disk(&disk_path).await
373    {
374        return Some(disk);
375    }
376
377    for disk in all_local_disk().await {
378        if remember_local_disk_id(&disk).await == Some(disk_id) {
379            return Some(disk);
380        }
381    }
382
383    None
384}
385
386pub async fn all_local_disk_path() -> Vec<String> {
387    runtime_sources::local_disk_paths().await
388}
389
390pub async fn all_local_disk() -> Vec<DiskStore> {
391    runtime_sources::local_disks().await
392}
393
394pub async fn prewarm_local_disk_id_map() {
395    prewarm_local_disk_id_map_with_instance_ctx(&crate::runtime::global::current_ctx()).await
396}
397
398/// Prewarm the disk-id map of an explicit instance context (Phase 5 follow-up,
399/// backlog#1052): startup passes the context whose disk map it just populated
400/// instead of resolving the process-level default.
401pub async fn prewarm_local_disk_id_map_with_instance_ctx(instance_ctx: &Arc<InstanceContext>) {
402    let disks: Vec<DiskStore> = instance_ctx
403        .local_disk_map()
404        .read()
405        .await
406        .values()
407        .filter_map(|v| v.as_ref().cloned())
408        .collect();
409    for disk in disks {
410        if let Err(err) = disk.get_disk_id().await {
411            debug!(
412                event = EVENT_LOCAL_DISK_ID_PREWARM_SKIPPED,
413                component = LOG_COMPONENT_ECSTORE,
414                subsystem = LOG_SUBSYSTEM_DISK_STARTUP,
415                disk_endpoint = %disk.endpoint(),
416                error = %err,
417                "Skipped local disk id prewarm"
418            );
419            continue;
420        }
421
422        let _ = remember_local_disk_id_with_instance_ctx(instance_ctx, &disk).await;
423    }
424}
425
426pub async fn init_local_disks(endpoint_pools: EndpointServerPools) -> Result<()> {
427    init_local_disks_with_instance_ctx(&crate::runtime::global::current_ctx(), endpoint_pools).await
428}
429
430/// Register the pools' local disks into an explicit instance context (Phase 5
431/// follow-up, backlog#1052). The legacy [`init_local_disks`] entry resolves the
432/// process-level default context; startup paths that own a context pass it here
433/// so a future second instance's disks cannot leak into the first one's registry.
434pub async fn init_local_disks_with_instance_ctx(
435    instance_ctx: &Arc<InstanceContext>,
436    endpoint_pools: EndpointServerPools,
437) -> Result<()> {
438    let opt = &DiskOption {
439        cleanup: true,
440        health_check: true,
441    };
442
443    runtime_sources::initialize_local_disk_maps(instance_ctx, endpoint_pools, opt).await
444}
445
446pub fn init_lock_clients(endpoint_pools: EndpointServerPools) {
447    let mut unique_endpoints: HashMap<String, &Endpoint> = HashMap::new();
448
449    for pool_eps in endpoint_pools.as_ref().iter() {
450        for ep in pool_eps.endpoints.as_ref().iter() {
451            unique_endpoints.insert(ep.host_port(), ep);
452        }
453    }
454
455    let mut clients = HashMap::new();
456    let mut first_local_client_set = false;
457
458    for (key, endpoint) in unique_endpoints {
459        if endpoint.is_local {
460            let local_client = Arc::new(LocalClient::new()) as Arc<dyn LockClient>;
461
462            // Store the first LocalClient globally for use by other modules
463            if !first_local_client_set {
464                if let Err(e) = runtime_sources::set_primary_lock_client(local_client.clone()) {
465                    // If already set, ignore the error (another thread may have set it)
466                    debug!(
467                        event = EVENT_LOCK_CLIENT_INITIALIZATION_FAILED,
468                        component = LOG_COMPONENT_ECSTORE,
469                        subsystem = LOG_SUBSYSTEM_DISK_STARTUP,
470                        error = ?e,
471                        reason = "global_lock_client_already_set",
472                        "Skipped global lock client publication"
473                    );
474                } else {
475                    first_local_client_set = true;
476                }
477            }
478
479            clients.insert(key, local_client);
480        } else {
481            clients.insert(key, Arc::new(RemoteClient::new(endpoint.url.to_string())) as Arc<dyn LockClient>);
482        }
483    }
484
485    // Store the lock clients map globally
486    if runtime_sources::set_lock_clients(clients).is_err() {
487        error!(
488            event = EVENT_LOCK_CLIENT_INITIALIZATION_FAILED,
489            component = LOG_COMPONENT_ECSTORE,
490            subsystem = LOG_SUBSYSTEM_DISK_STARTUP,
491            reason = "set_global_lock_clients_failed",
492            "Failed to initialize lock clients"
493        );
494    }
495}
496
497fn endpoint_rpc_authority(endpoint: &Endpoint) -> Option<String> {
498    let host = endpoint.url.host_str()?;
499    let host = if host.contains(':') && !host.starts_with('[') {
500        format!("[{host}]")
501    } else {
502        host.to_string()
503    };
504    Some(match endpoint.url.port() {
505        Some(port) => format!("{host}:{port}"),
506        None => host,
507    })
508}
509
510pub(super) async fn init_local_peer(endpoint_pools: &EndpointServerPools, host: &String, port: &String) {
511    let mut peer_set = Vec::new();
512    endpoint_pools.as_ref().iter().for_each(|endpoints| {
513        endpoints.endpoints.as_ref().iter().for_each(|endpoint| {
514            if endpoint.get_type() == EndpointType::Url
515                && endpoint.is_local
516                && let Some(authority) = endpoint_rpc_authority(endpoint)
517            {
518                peer_set.push(authority);
519            }
520        });
521    });
522
523    if peer_set.is_empty() {
524        if !host.is_empty() {
525            runtime_sources::set_local_node_name(format!("{host}:{port}")).await;
526            return;
527        }
528
529        runtime_sources::set_local_node_name(format!("127.0.0.1:{port}")).await;
530        return;
531    }
532
533    runtime_sources::set_local_node_name(peer_set[0].clone()).await;
534}
535
536pub async fn get_disk_infos(disks: &[Option<DiskStore>]) -> Vec<Option<DiskInfo>> {
537    let opts = &DiskInfoOptions::default();
538    let mut res = vec![None; disks.len()];
539    for (idx, disk_op) in disks.iter().enumerate() {
540        if let Some(disk) = disk_op
541            && let Ok(info) = disk.disk_info(opts).await
542        {
543            res[idx] = Some(info);
544        }
545    }
546
547    res
548}
549
550#[cfg(test)]
551mod tests {
552    use super::*;
553    use crate::disk::new_disk;
554    use crate::layout::endpoints::{Endpoints, PoolEndpoints};
555
556    fn single_local_disk_pools(dir: &std::path::Path) -> EndpointServerPools {
557        let mut endpoint = Endpoint::try_from(dir.to_str().expect("temp dir path should be utf-8")).expect("local endpoint");
558        endpoint.set_pool_index(0);
559        endpoint.set_set_index(0);
560        endpoint.set_disk_index(0);
561
562        EndpointServerPools(vec![PoolEndpoints {
563            legacy: false,
564            set_count: 1,
565            drives_per_set: 1,
566            endpoints: Endpoints::from(vec![endpoint]),
567            cmd_line: "instance-ctx-disk-registry-test".to_string(),
568            platform: "test".to_string(),
569        }])
570    }
571
572    async fn target_disk(ctx: &Arc<InstanceContext>, root: &std::path::Path, id: Uuid) -> DiskStore {
573        let mut format = crate::layout::format::FormatV3::new(1, 1);
574        format.erasure.this = id;
575        format.erasure.sets[0][0] = id;
576        let meta = root.join(crate::disk::RUSTFS_META_BUCKET);
577        tokio::fs::create_dir_all(&meta).await.expect("create format volume");
578        tokio::fs::write(
579            meta.join(crate::disk::FORMAT_CONFIG_FILE),
580            serde_json::to_vec(&format).expect("encode format"),
581        )
582        .await
583        .expect("write real disk identity");
584        let mut endpoint = Endpoint::try_from(root.to_str().expect("UTF-8 root")).expect("endpoint");
585        endpoint.set_pool_index(0);
586        endpoint.set_set_index(0);
587        endpoint.set_disk_index(0);
588        let disk = new_disk(
589            &endpoint,
590            &DiskOption {
591                cleanup: false,
592                health_check: false,
593            },
594        )
595        .await
596        .expect("open real local disk");
597        assert_eq!(disk.get_disk_id().await.expect("read disk format identity"), Some(id));
598        ctx.local_disk_map()
599            .write()
600            .await
601            .insert(disk.endpoint().to_string(), Some(disk.clone()));
602        disk
603    }
604
605    fn target_file_info(object: &str, version: Uuid, body: &'static [u8]) -> FileInfo {
606        let mut fi = FileInfo::new(object, 1, 0);
607        fi.erasure.index = 1;
608        fi.version_id = Some(version);
609        fi.mod_time = Some(OffsetDateTime::now_utc());
610        fi.size = i64::try_from(body.len()).expect("fixture length");
611        fi.parts = vec![rustfs_filemeta::ObjectPartInfo {
612            number: 1,
613            size: body.len(),
614            actual_size: fi.size,
615            ..Default::default()
616        }];
617        fi.data = Some(bytes::Bytes::from_static(body));
618        fi.set_inline_data();
619        fi
620    }
621
622    async fn seed_target(disk: &DiskStore, volume: &str, object: &str, fi: FileInfo) -> Vec<u8> {
623        let dir = disk.path().join(volume);
624        tokio::fs::create_dir_all(&dir).await.expect("real fixture volume");
625        disk.write_metadata(volume, volume, object, fi.clone())
626            .await
627            .expect("seed real metadata");
628        let read = disk
629            .read_version(
630                volume,
631                volume,
632                object,
633                &fi.version_id.expect("fixture version").to_string(),
634                &crate::disk::ReadOptions {
635                    read_data: true,
636                    ..Default::default()
637                },
638            )
639            .await
640            .expect("read fixture before mutation");
641        assert_eq!(read.data, fi.data, "fixture must contain readable inline bytes");
642        tokio::fs::read(dir.join(object).join(crate::disk::STORAGE_FORMAT_FILE))
643            .await
644            .expect("seeded metadata bytes")
645    }
646
647    #[tokio::test]
648    async fn target_uuid_lookup_binds_real_disk_and_owner_to_one_instance() {
649        for warm in [false, true] {
650            let ctx_a = Arc::new(InstanceContext::new());
651            let ctx_b = Arc::new(InstanceContext::new());
652            let a = tempfile::tempdir().expect("A root");
653            let b = tempfile::tempdir().expect("B root");
654            let id = Uuid::new_v4();
655            let disk_a = target_disk(&ctx_a, a.path(), id).await;
656            let disk_b = target_disk(&ctx_b, b.path(), id).await;
657            if warm {
658                assert!(record_local_disk_id_if_active(&ctx_a, &disk_a, id).await);
659                assert!(record_local_disk_id_if_active(&ctx_b, &disk_b, id).await);
660            }
661            let version = Uuid::new_v4();
662            let fi = target_file_info("destination", version, b"new-A");
663            for disk in [&disk_a, &disk_b] {
664                seed_target(disk, "target-bucket", "staged", fi.clone()).await;
665            }
666            let b_before = seed_target(
667                &disk_b,
668                "target-bucket",
669                "destination",
670                target_file_info("destination", version, b"old-B"),
671            )
672            .await;
673            let store = super::super::tests::build_store_with_ctx(ctx_a.clone());
674            store
675                .rename_local_data(&id.to_string(), ("target-bucket", "staged"), &fi, ("target-bucket", "destination"), None)
676                .await
677                .expect("rename on A");
678            let read = disk_a
679                .read_version(
680                    "target-bucket",
681                    "target-bucket",
682                    "destination",
683                    &version.to_string(),
684                    &crate::disk::ReadOptions {
685                        read_data: true,
686                        ..Default::default()
687                    },
688                )
689                .await
690                .expect("read committed A");
691            assert_eq!(read.data, fi.data, "warm={warm}");
692            assert_eq!(
693                tokio::fs::read(b.path().join("target-bucket/destination/xl.meta"))
694                    .await
695                    .expect("B metadata"),
696                b_before
697            );
698            assert!(b.path().join("target-bucket/staged/xl.meta").exists());
699            assert!(ctx_a.namespace_commit_generation() > 0);
700            assert_eq!(ctx_b.namespace_commit_generation(), 0);
701            assert!(!ctx_a.namespace_commits_pending());
702            assert!(!ctx_b.namespace_commits_pending());
703            assert_eq!(ctx_a.local_disk_id_map().read().await.get(&id), Some(&disk_a.endpoint().to_string()));
704        }
705    }
706
707    #[tokio::test]
708    async fn target_admission_rejects_removed_quarantined_and_replaced_arcs() {
709        let ctx = Arc::new(InstanceContext::new());
710        let root = tempfile::tempdir().expect("root");
711        let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
712        let endpoint = disk.endpoint().to_string();
713        for state in ["removed", "quarantined", "replaced"] {
714            let replacement = new_disk(
715                &disk.endpoint(),
716                &DiskOption {
717                    cleanup: false,
718                    health_check: false,
719                },
720            )
721            .await
722            .expect("separate active Arc");
723            let map = ctx.local_disk_map();
724            let mut entries = map.write().await;
725            match state {
726                "removed" => {
727                    entries.remove(&endpoint);
728                }
729                "quarantined" => {
730                    entries.insert(endpoint.clone(), None);
731                }
732                _ => {
733                    entries.insert(endpoint.clone(), Some(replacement));
734                }
735            }
736            drop(entries);
737            assert!(
738                matches!(admit_local_disk(&ctx, &disk, None, true).await, Err(DiskError::DiskNotFound)),
739                "{state}"
740            );
741            assert!(!ctx.namespace_commits_pending());
742            assert_eq!(ctx.namespace_commit_generation(), 0);
743        }
744    }
745
746    #[tokio::test]
747    async fn target_uuid_cache_cannot_admit_a_different_format_at_the_same_path() {
748        let ctx = Arc::new(InstanceContext::new());
749        let root = tempfile::tempdir().expect("root");
750        let old_id = Uuid::new_v4();
751        let old = target_disk(&ctx, root.path(), old_id).await;
752        assert!(record_local_disk_id_if_active(&ctx, &old, old_id).await);
753        let replacement_id = Uuid::new_v4();
754        let replacement = target_disk(&ctx, root.path(), replacement_id).await;
755        assert!(!Arc::ptr_eq(&old, &replacement));
756        assert!(matches!(
757            local_disk_candidate(&ctx, &old_id.to_string()).await,
758            Err(DiskError::DiskNotFound)
759        ));
760        let (candidate, verified) = local_disk_candidate(&ctx, &replacement_id.to_string())
761            .await
762            .expect("replacement UUID");
763        assert!(Arc::ptr_eq(&candidate, &replacement));
764        assert_eq!(verified, Some(replacement_id));
765        assert!(!ctx.namespace_commits_pending());
766    }
767
768    #[tokio::test]
769    async fn bootstrap_rejects_user_volumes_aliases_and_scanner_tokens_without_mutation() {
770        let ctx = Arc::new(InstanceContext::new());
771        let root = tempfile::tempdir().expect("root");
772        let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
773        let target = BootstrapLocalTarget::new(ctx.clone());
774        let fi = target_file_info("destination", Uuid::new_v4(), b"body");
775        let user_before = seed_target(&disk, "victim", "staged", fi.clone()).await;
776        let meta_before = seed_target(&disk, ".rustfs.sys/tmp", "staged", fi.clone()).await;
777        for invalid in [
778            "victim",
779            ".rustfs.sys/../victim",
780            ".rustfs.sys/./tmp",
781            ".rustfs.sys/ .. /victim",
782            ".rustfs.sys\\..\\victim",
783            ".minio.sys/../victim",
784        ] {
785            for (src, dst) in [(invalid, ".rustfs.sys/tmp"), (".rustfs.sys/tmp", invalid)] {
786                assert!(
787                    target
788                        .rename_local_data(&disk.endpoint().to_string(), (src, "staged"), &fi, (dst, "destination"), None)
789                        .await
790                        .is_err(),
791                    "src={src}, dst={dst}"
792                );
793            }
794            assert!(
795                target
796                    .undo_local_write(
797                        &disk.endpoint().to_string(),
798                        invalid,
799                        "staged",
800                        fi.clone(),
801                        DeleteOptions {
802                            undo_write: true,
803                            ..Default::default()
804                        }
805                    )
806                    .await
807                    .is_err(),
808                "{invalid}"
809            );
810        }
811        assert!(
812            target
813                .rename_local_data(
814                    &disk.endpoint().to_string(),
815                    (".rustfs.sys/tmp", "staged"),
816                    &fi,
817                    (".rustfs.sys/tmp", "destination"),
818                    Some(Uuid::new_v4())
819                )
820                .await
821                .is_err()
822        );
823        assert_eq!(
824            tokio::fs::read(root.path().join("victim/staged/xl.meta"))
825                .await
826                .expect("user source"),
827            user_before
828        );
829        assert_eq!(
830            tokio::fs::read(root.path().join(".rustfs.sys/tmp/staged/xl.meta"))
831                .await
832                .expect("metadata source"),
833            meta_before
834        );
835        assert!(!root.path().join("victim/destination").exists());
836        assert!(!root.path().join(".rustfs.sys/tmp/destination").exists());
837        assert_eq!(ctx.namespace_commit_generation(), 0);
838        assert!(!ctx.namespace_commits_pending());
839    }
840
841    #[tokio::test]
842    async fn bootstrap_allows_internal_multisegment_rename_without_namespace_owner() {
843        for volume in [".rustfs.sys/tmp", ".rustfs.sys/multipart", ".minio.sys/config"] {
844            let ctx = Arc::new(InstanceContext::new());
845            let root = tempfile::tempdir().expect("root");
846            let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
847            let fi = target_file_info("destination", Uuid::new_v4(), b"internal-CAS-body");
848            seed_target(&disk, volume, "staged", fi.clone()).await;
849            BootstrapLocalTarget::new(ctx.clone())
850                .rename_local_data(&disk.endpoint().to_string(), (volume, "staged"), &fi, (volume, "destination"), None)
851                .await
852                .expect("legitimate bootstrap metadata write");
853            let read = disk
854                .read_version(
855                    volume,
856                    volume,
857                    "destination",
858                    &fi.version_id.expect("version").to_string(),
859                    &crate::disk::ReadOptions {
860                        read_data: true,
861                        ..Default::default()
862                    },
863                )
864                .await
865                .expect("read bootstrap result");
866            assert_eq!(read.data, fi.data);
867            assert_eq!(ctx.namespace_commit_generation(), 0);
868            assert!(!ctx.namespace_commits_pending());
869        }
870    }
871
872    #[cfg(not(windows))]
873    #[tokio::test]
874    async fn target_user_source_to_internal_destination_retains_owner_after_cancellation() {
875        use crate::disk::os::prepared_publication_test_hooks as hooks;
876        use futures::FutureExt;
877        use std::time::Duration;
878
879        let ctx = Arc::new(InstanceContext::new());
880        let root = tempfile::tempdir().expect("source-volume root");
881        let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
882        let store = super::super::tests::build_store_with_ctx(ctx.clone());
883        let version = Uuid::new_v4();
884        let fi = target_file_info("object", version, b"user-source-inline-body");
885        fi.validate_for_metadata_read().expect("valid real inline metadata");
886        let source_before = seed_target(&disk, "photos", "object", fi.clone()).await;
887        assert!(!source_before.is_empty());
888        tokio::fs::create_dir_all(root.path().join(crate::disk::RUSTFS_META_TMP_BUCKET))
889            .await
890            .expect("internal staging volume");
891        let destination = disk
892            .get_object_path_for_io_if_local(crate::disk::RUSTFS_META_TMP_BUCKET, "object")
893            .expect("local disk")
894            .expect("actual destination object key");
895        let destination_metadata = destination.join(crate::disk::STORAGE_FORMAT_FILE);
896        assert!(!destination_metadata.exists());
897        assert!(!ctx.namespace_commits_pending());
898        let generation = ctx.namespace_commit_generation();
899        let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
900        let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
901        let _hook = hooks::install(&destination_metadata, move || {
902            let _ = entered_tx.send(());
903            let _ = release_rx.recv();
904        });
905        let disk_ref = disk.endpoint().to_string();
906        let rename_fi = fi.clone();
907        let mut rename = tokio::spawn(async move {
908            store
909                .rename_local_data(
910                    &disk_ref,
911                    ("photos", "object"),
912                    &rename_fi,
913                    (crate::disk::RUSTFS_META_TMP_BUCKET, "object"),
914                    None,
915                )
916                .await
917        });
918        let mut entered = false;
919        let mut joined = false;
920        let observations = std::panic::AssertUnwindSafe(async {
921            tokio::time::timeout(Duration::from_secs(10), async {
922                tokio::select! {
923                    result = &mut rename => {
924                        joined = true;
925                        panic!("rename completed before prepared publication: {result:?}");
926                    }
927                    result = entered_rx => {
928                        result.expect("real prepared rename must enter");
929                        entered = true;
930                    }
931                }
932            })
933            .await
934            .expect("bounded physical entry");
935            let at_entry = (ctx.namespace_commits_pending(), ctx.namespace_commit_generation());
936            assert!(!rename.is_finished(), "caller must still await the paused physical rename");
937            rename.abort();
938            let cancelled = tokio::time::timeout(Duration::from_secs(5), &mut rename)
939                .await
940                .expect("caller cancellation must finish while physical publication is paused");
941            joined = true;
942            let after_cancel = (ctx.namespace_commits_pending(), ctx.namespace_commit_generation());
943            (at_entry, after_cancel, cancelled)
944        })
945        .catch_unwind()
946        .await;
947
948        // Release on every observation failure. Pending alone is not a drain
949        // oracle: the implementation under test can fail to create the owner.
950        drop(release_tx);
951        if !joined {
952            rename.abort();
953            joined = tokio::time::timeout(Duration::from_secs(5), &mut rename).await.is_ok();
954        }
955        let physical_drained = tokio::time::timeout(Duration::from_secs(10), hooks::drain_namespace_key(&destination)).await;
956        let owner_drained = tokio::time::timeout(Duration::from_secs(10), async {
957            while ctx.namespace_commits_pending() {
958                tokio::task::yield_now().await;
959            }
960        })
961        .await;
962        if !entered || !joined || physical_drained.is_err() || owner_drained.is_err() {
963            // Without proven physical entry/drain, keep the root instead of
964            // deleting files that a detached local executor may still use.
965            let retained = root.keep();
966            eprintln!("source-volume cleanup incomplete: entered={entered}, joined={joined}, retained={retained:?}");
967            if let Err(panic) = observations {
968                std::panic::resume_unwind(panic);
969            }
970            panic!("source-volume physical cleanup did not finish: retained={retained:?}");
971        }
972        let (at_entry, after_cancel, cancelled) = match observations {
973            Ok(observations) => observations,
974            Err(panic) => std::panic::resume_unwind(panic),
975        };
976        let latest = tokio::time::timeout(
977            Duration::from_secs(5),
978            disk.read_version(
979                crate::disk::RUSTFS_META_TMP_BUCKET,
980                crate::disk::RUSTFS_META_TMP_BUCKET,
981                "object",
982                "",
983                &crate::disk::ReadOptions {
984                    read_data: true,
985                    ..Default::default()
986                },
987            ),
988        )
989        .await;
990        let source =
991            tokio::time::timeout(Duration::from_secs(5), tokio::fs::read(root.path().join("photos/object/xl.meta"))).await;
992        let after_drain = (ctx.namespace_commits_pending(), ctx.namespace_commit_generation());
993        assert!(cancelled.expect_err("caller must return cancellation").is_cancelled());
994        let latest = latest
995            .expect("latest read must finish")
996            .expect("late physical commit must be readable");
997        assert_eq!(latest.data, fi.data);
998        assert_eq!(latest.version_id, Some(version));
999        assert_eq!(
1000            source
1001                .expect("source observation must finish")
1002                .expect_err("user source metadata must have moved")
1003                .kind(),
1004            std::io::ErrorKind::NotFound
1005        );
1006        assert_eq!(
1007            (at_entry, after_cancel, after_drain),
1008            ((true, generation + 1), (true, generation + 1), (false, generation + 2)),
1009            "a real user source mutation must remain counted through its cancelled caller and physical drain"
1010        );
1011    }
1012
1013    #[cfg(not(windows))]
1014    #[tokio::test]
1015    async fn target_rename_cancellation_retains_real_namespace_and_scanner_owners() {
1016        use crate::disk::os::prepared_publication_test_hooks as hooks;
1017        let ctx = Arc::new(InstanceContext::new());
1018        let sibling = Arc::new(InstanceContext::new());
1019        let root = tempfile::tempdir().expect("root");
1020        let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
1021        let store = super::super::tests::build_store_with_ctx(ctx.clone());
1022        let fi = target_file_info("destination", Uuid::new_v4(), b"physically-owned");
1023        seed_target(&disk, "target-bucket", "staged", fi.clone()).await;
1024        let (token, _) = store
1025            .acquire_scanner_publication_lease(0, crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL)
1026            .await
1027            .expect("real scanner token in A");
1028        let destination = disk
1029            .get_object_path_for_io_if_local("target-bucket", "destination/xl.meta")
1030            .expect("local disk")
1031            .expect("destination IO path");
1032        let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
1033        let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
1034        let _hook = hooks::install(&destination, move || {
1035            let _ = entered_tx.send(());
1036            let _ = release_rx.recv();
1037        });
1038        let disk_ref = disk.endpoint().to_string();
1039        let mut rename = Box::pin(store.rename_local_data(
1040            &disk_ref,
1041            ("target-bucket", "staged"),
1042            &fi,
1043            ("target-bucket", "destination"),
1044            Some(token),
1045        ));
1046        tokio::time::timeout(std::time::Duration::from_secs(10), async {
1047            tokio::select! {
1048                result = &mut rename => panic!("rename completed before physical pause: {result:?}"),
1049                entered = entered_rx => entered.expect("physical rename entered"),
1050            }
1051        })
1052        .await
1053        .expect("bounded physical entry");
1054        drop(rename);
1055        assert!(store.scanner_data_usage_publication_blocked().await);
1056        assert!(ctx.namespace_commits_pending());
1057        assert!(!sibling.namespace_commits_pending());
1058        assert!(
1059            store
1060                .rename_local_data(&disk_ref, ("target-bucket", "staged"), &fi, ("target-bucket", "another"), Some(token))
1061                .await
1062                .is_err(),
1063            "real pending rename blocks another scanner publication"
1064        );
1065        assert!(store.release_scanner_publication_lease(token).await, "remove registered token");
1066        let gate = ctx.data_movement_operation_gate();
1067        assert!(
1068            gate.clone().try_write_owned().is_err(),
1069            "physical operation still owns the scanner read guard"
1070        );
1071        drop(release_tx);
1072        let _drained = tokio::time::timeout(std::time::Duration::from_secs(10), gate.write_owned())
1073            .await
1074            .expect("physical tail must release scanner guard");
1075        tokio::time::timeout(std::time::Duration::from_secs(10), async {
1076            while ctx.namespace_commits_pending() {
1077                tokio::task::yield_now().await;
1078            }
1079        })
1080        .await
1081        .expect("namespace owner drains");
1082        let read = disk
1083            .read_version(
1084                "target-bucket",
1085                "target-bucket",
1086                "destination",
1087                &fi.version_id.expect("version").to_string(),
1088                &crate::disk::ReadOptions {
1089                    read_data: true,
1090                    ..Default::default()
1091                },
1092            )
1093            .await
1094            .expect("read actual late commit");
1095        assert_eq!(read.data, fi.data);
1096        assert!(ctx.namespace_commit_generation() >= 2);
1097        assert_eq!(sibling.namespace_commit_generation(), 0);
1098    }
1099
1100    #[tokio::test]
1101    async fn target_ready_rejects_unknown_foreign_released_and_expired_scanner_tokens() {
1102        let ctx = Arc::new(InstanceContext::new());
1103        let other = Arc::new(InstanceContext::new());
1104        let store = super::super::tests::build_store_with_ctx(ctx.clone());
1105        let other_store = super::super::tests::build_store_with_ctx(other);
1106        let root = tempfile::tempdir().expect("root");
1107        let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
1108        let fi = target_file_info("destination", Uuid::new_v4(), b"unchanged");
1109        let before = seed_target(&disk, "target-bucket", "staged", fi.clone()).await;
1110        let ttl = crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL;
1111        let (foreign, _) = other_store.acquire_scanner_publication_lease(0, ttl).await.expect("B token");
1112        let (released, _) = store.acquire_scanner_publication_lease(0, ttl).await.expect("A token");
1113        assert!(store.release_scanner_publication_lease(released).await);
1114        let (valid, _) = store.acquire_scanner_publication_lease(0, ttl).await.expect("new A token");
1115        for token in [Uuid::new_v4(), foreign, released] {
1116            assert!(
1117                store
1118                    .rename_local_data(
1119                        &disk.endpoint().to_string(),
1120                        ("target-bucket", "staged"),
1121                        &fi,
1122                        ("target-bucket", "destination"),
1123                        Some(token)
1124                    )
1125                    .await
1126                    .is_err()
1127            );
1128        }
1129        tokio::time::pause();
1130        tokio::time::advance(ttl + std::time::Duration::from_secs(1)).await;
1131        tokio::time::resume();
1132        assert!(
1133            store
1134                .rename_local_data(
1135                    &disk.endpoint().to_string(),
1136                    ("target-bucket", "staged"),
1137                    &fi,
1138                    ("target-bucket", "destination"),
1139                    Some(valid)
1140                )
1141                .await
1142                .is_err(),
1143            "expired real token"
1144        );
1145        let _ = other_store.release_scanner_publication_lease(foreign).await;
1146        assert_eq!(
1147            tokio::fs::read(root.path().join("target-bucket/staged/xl.meta"))
1148                .await
1149                .expect("source bytes"),
1150            before
1151        );
1152        assert!(!root.path().join("target-bucket/destination").exists());
1153        assert!(!ctx.namespace_commits_pending());
1154    }
1155
1156    #[tokio::test]
1157    async fn completed_namespace_commit_rejects_stale_scanner_target_admission() {
1158        use futures::FutureExt;
1159        use std::time::{Duration, Instant};
1160        use tokio::time::timeout;
1161
1162        let ttl = crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL;
1163        let ctx = Arc::new(InstanceContext::new());
1164        let root = tempfile::tempdir().expect("target root");
1165        let user_volume = "target-bucket";
1166        let metadata_volume = ".rustfs.sys/tmp";
1167        let setup = std::panic::AssertUnwindSafe(timeout(ttl / 2, async {
1168            let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
1169            let old_time = OffsetDateTime::from_unix_timestamp(1_700_000_000).expect("fixed fixture modtime");
1170            let new_time = old_time + time::Duration::seconds(1);
1171            let mut user_old = target_file_info("destination", Uuid::new_v4(), b"user-before-scan");
1172            let mut user_new = target_file_info("destination", Uuid::new_v4(), b"user-after-scan");
1173            let mut metadata_old = target_file_info("destination", Uuid::new_v4(), b"metadata-before-stale-admission");
1174            let mut metadata_new = target_file_info("destination", Uuid::new_v4(), b"metadata-from-stale-scan");
1175            user_old.mod_time = Some(old_time);
1176            metadata_old.mod_time = Some(old_time);
1177            user_new.mod_time = Some(new_time);
1178            metadata_new.mod_time = Some(new_time);
1179            seed_target(&disk, user_volume, "destination", user_old).await;
1180            seed_target(&disk, user_volume, "staged", user_new.clone()).await;
1181            let metadata_before = seed_target(&disk, metadata_volume, "destination", metadata_old.clone()).await;
1182            seed_target(&disk, metadata_volume, "staged", metadata_new.clone()).await;
1183            (disk, user_new, metadata_old, metadata_new, metadata_before)
1184        }))
1185        .catch_unwind()
1186        .await;
1187        let (disk, user_new, metadata_old, metadata_new, metadata_before) = match setup {
1188            Ok(Ok(setup)) => setup,
1189            Ok(Err(error)) => {
1190                let retained = root.keep();
1191                panic!("fixture initialization must finish before lease acquisition: {error}; retained={retained:?}");
1192            }
1193            Err(panic) => {
1194                let retained = root.keep();
1195                eprintln!("fixture setup panicked; retained={retained:?}");
1196                std::panic::resume_unwind(panic);
1197            }
1198        };
1199        let store = super::super::tests::build_store_with_ctx(ctx.clone());
1200        let disk_ref = disk.endpoint().to_string();
1201        let metadata_path = root.path().join(metadata_volume).join("destination/xl.meta");
1202        let read_options = crate::disk::ReadOptions {
1203            read_data: true,
1204            ..Default::default()
1205        };
1206        let namespace_before = ctx.namespace_commit_generation();
1207        let namespace_completed = namespace_before.checked_add(2).expect("one begin and one physical drain");
1208        let movement_before = ctx.data_movement_generation();
1209        let operation_epoch_before = ctx.data_movement_operation_epoch();
1210        let mut acquired_token = None;
1211
1212        // Use real monotonic time: expiry must not supply a false rejection.
1213        let started = Instant::now();
1214        let observations = std::panic::AssertUnwindSafe(timeout(ttl / 2, async {
1215            assert!(!ctx.namespace_commits_pending(), "all fixture writes precede the baseline");
1216            let (token, generation) = store
1217                .acquire_scanner_publication_lease(movement_before, ttl)
1218                .await
1219                .expect("precondition: acquire a real current lease");
1220            acquired_token = Some(token);
1221            assert_eq!(generation, movement_before);
1222            store
1223                .validate_scanner_publication_lease(token, movement_before)
1224                .await
1225                .expect("precondition: validate succeeds before the ordinary commit");
1226            drop(
1227                store
1228                    .acquire_scanner_publication_lease_guard(token)
1229                    .await
1230                    .expect("precondition: actual target guard lookup accepts the live token"),
1231            );
1232            assert_eq!(ctx.namespace_commit_generation(), namespace_before);
1233            store
1234                .rename_local_data(&disk_ref, (user_volume, "staged"), &user_new, (user_volume, "destination"), None)
1235                .await
1236                .expect("precondition: complete a real ordinary rename after the successful lease checks");
1237            let ordinary = disk
1238                .read_version(user_volume, user_volume, "destination", "", &read_options)
1239                .await
1240                .expect("precondition: read latest ordinary committed body");
1241            assert_eq!(ordinary.data, user_new.data);
1242            assert_eq!(ordinary.version_id, user_new.version_id);
1243            while ctx.namespace_commits_pending() {
1244                tokio::task::yield_now().await;
1245            }
1246            assert_eq!(
1247                ctx.namespace_commit_generation(),
1248                namespace_completed,
1249                "ordinary physical owner must fully drain"
1250            );
1251            assert_eq!(ctx.data_movement_generation(), movement_before);
1252            assert_eq!(ctx.data_movement_operation_epoch(), operation_epoch_before);
1253
1254            // Collect both admissions and the physical result before asserting
1255            // rejection, so the first failure cannot hide the second entrypoint.
1256            let stale_validate = store.validate_scanner_publication_lease(token, movement_before).await;
1257            let target_rename = store
1258                .rename_local_data(
1259                    &disk_ref,
1260                    (metadata_volume, "staged"),
1261                    &metadata_new,
1262                    (metadata_volume, "destination"),
1263                    Some(token),
1264                )
1265                .await;
1266            let metadata_latest = disk
1267                .read_version(metadata_volume, metadata_volume, "destination", "", &read_options)
1268                .await;
1269            let metadata_after = tokio::fs::read(&metadata_path).await;
1270            let user_latest = disk
1271                .read_version(user_volume, user_volume, "destination", "", &read_options)
1272                .await;
1273            let final_state = (
1274                ctx.namespace_commits_pending(),
1275                ctx.namespace_commit_generation(),
1276                ctx.data_movement_generation(),
1277                ctx.data_movement_operation_epoch(),
1278            );
1279            (stale_validate, target_rename, metadata_latest, metadata_after, user_latest, final_state)
1280        }))
1281        .catch_unwind()
1282        .await;
1283        let observed_after = started.elapsed();
1284        // A table release does not drain an independently owned metadata call.
1285        // Collect every release outcome before checking either ownership chain.
1286        let cleanup = std::panic::AssertUnwindSafe(async {
1287            let mut releases = Vec::new();
1288            if let Some(token) = acquired_token {
1289                releases.push(
1290                    std::panic::AssertUnwindSafe(timeout(Duration::from_secs(5), store.release_scanner_publication_lease(token)))
1291                        .catch_unwind()
1292                        .await,
1293                );
1294            }
1295            let movement_guard = timeout(Duration::from_secs(5), ctx.data_movement_operation_gate().write_owned()).await;
1296            let namespace_drained = timeout(Duration::from_secs(5), async {
1297                while ctx.namespace_commits_pending() {
1298                    tokio::task::yield_now().await;
1299                }
1300            })
1301            .await;
1302            let drained = releases.iter().all(|release| matches!(release, Ok(Ok(_))))
1303                && movement_guard.is_ok()
1304                && namespace_drained.is_ok();
1305            #[cfg(not(windows))]
1306            let drained = {
1307                use crate::disk::os::prepared_publication_test_hooks as hooks;
1308
1309                let mut keys_drained = true;
1310                for volume in [user_volume, metadata_volume] {
1311                    // The physical lease uses the actual IO object directory,
1312                    // including descriptor-rooted aliases, not its xl.meta file.
1313                    let key_drained = match disk.get_object_path_for_io_if_local(volume, "destination") {
1314                        Some(Ok(path)) => timeout(Duration::from_secs(5), hooks::drain_namespace_key(&path))
1315                            .await
1316                            .is_ok(),
1317                        _ => false,
1318                    };
1319                    keys_drained &= key_drained;
1320                }
1321                drained && keys_drained
1322            };
1323            drop(movement_guard);
1324            if let Some(panic) = releases.into_iter().find_map(|release| release.err()) {
1325                std::panic::resume_unwind(panic);
1326            }
1327            drained
1328        })
1329        .catch_unwind()
1330        .await;
1331        // Generic cancelled IO cannot be proved drained by a namespace key.
1332        // Retain on any failed observation, even if best-effort cleanup succeeds.
1333        if !matches!(&observations, Ok(Ok((_, _, Ok(_), Ok(_), Ok(_), _)))) || !matches!(&cleanup, Ok(true)) {
1334            let retained = root.keep();
1335            eprintln!("fixture observations or physical cleanup incomplete; retained={retained:?}");
1336        }
1337        let observations = match observations {
1338            Ok(result) => result.expect("fixture timed out before complete observations; not a namespace rejection result"),
1339            Err(panic) => std::panic::resume_unwind(panic),
1340        };
1341        match cleanup {
1342            Ok(drained) => assert!(drained, "fixture physical cleanup must finish before deleting its root"),
1343            Err(panic) => std::panic::resume_unwind(panic),
1344        }
1345        assert!(
1346            observed_after < ttl,
1347            "fixture lease expired before observation: elapsed={observed_after:?}, ttl={ttl:?}"
1348        );
1349        assert!(
1350            observed_after < ttl / 2,
1351            "fixture exceeded its half-TTL observation budget: {observed_after:?}"
1352        );
1353        let (stale_validate, target_rename, metadata_latest, metadata_after, user_latest, final_state) = observations;
1354        let metadata_latest = metadata_latest.expect("observation: latest metadata must remain decodable");
1355        let metadata_after = metadata_after.expect("observation: read raw destination xl.meta");
1356        let user_latest = user_latest.expect("observation: latest ordinary body must remain decodable");
1357        let metadata_changed = metadata_after != metadata_before;
1358        let latest_is_staged = metadata_latest.version_id == metadata_new.version_id && metadata_latest.data == metadata_new.data;
1359        eprintln!(
1360            "namespace admission observation: stale_validate={stale_validate:?}, target_rename={:?}, metadata_changed={metadata_changed}, latest_is_staged={latest_is_staged}, latest_version={:?}, latest_body={:?}, final_state={final_state:?}, elapsed={observed_after:?}, ttl={ttl:?}",
1361            target_rename.as_ref().map(|_| ()),
1362            metadata_latest.version_id,
1363            metadata_latest.data,
1364        );
1365        assert_eq!(final_state, (false, namespace_completed, movement_before, operation_epoch_before));
1366        assert_eq!(user_latest.data, user_new.data);
1367        assert_eq!(user_latest.version_id, user_new.version_id);
1368        assert!(
1369            stale_validate.is_err() && target_rename.is_err(),
1370            "completed namespace commit must reject both stale admissions: validate={stale_validate:?}, target={:?}, metadata_changed={metadata_changed}",
1371            target_rename.as_ref().map(|_| ()),
1372        );
1373        assert_eq!(metadata_after, metadata_before, "stale target must not rewrite metadata");
1374        assert_eq!(metadata_latest.data, metadata_old.data, "latest metadata body must remain the old one");
1375        assert_eq!(
1376            metadata_latest.version_id, metadata_old.version_id,
1377            "latest metadata version must remain the old one"
1378        );
1379    }
1380
1381    #[tokio::test]
1382    async fn renewed_namespace_lease_allows_real_metadata_publication() {
1383        use futures::FutureExt;
1384        use std::time::Duration;
1385        use tokio::time::timeout;
1386
1387        let ctx = Arc::new(InstanceContext::new());
1388        let store = super::super::tests::build_store_with_ctx(ctx.clone());
1389        let root = tempfile::tempdir().expect("target root");
1390        let ttl = crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL;
1391        let user_volume = "target-bucket";
1392        let metadata_volume = ".rustfs.sys/tmp";
1393        let setup = std::panic::AssertUnwindSafe(timeout(ttl / 2, async {
1394            let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
1395            let user_new = target_file_info("destination", Uuid::new_v4(), b"completed-user-write");
1396            let mut metadata_old = target_file_info("destination", Uuid::new_v4(), b"old-metadata");
1397            let mut metadata_new = target_file_info("destination", Uuid::new_v4(), b"metadata-from-renewed-scan");
1398            metadata_old.mod_time = Some(OffsetDateTime::from_unix_timestamp(1_700_000_000).expect("fixed old time"));
1399            metadata_new.mod_time = metadata_old.mod_time.map(|old| old + time::Duration::seconds(1));
1400            seed_target(&disk, user_volume, "staged", user_new.clone()).await;
1401            let metadata_before = seed_target(&disk, metadata_volume, "destination", metadata_old).await;
1402            seed_target(&disk, metadata_volume, "staged", metadata_new.clone()).await;
1403            (disk, user_new, metadata_new, metadata_before)
1404        }))
1405        .catch_unwind()
1406        .await;
1407        let (disk, user_new, metadata_new, metadata_before) = match setup {
1408            Ok(Ok(setup)) => setup,
1409            Ok(Err(error)) => {
1410                let retained = root.keep();
1411                panic!("fixture initialization must finish before lease acquisition: {error}; retained={retained:?}");
1412            }
1413            Err(panic) => {
1414                let retained = root.keep();
1415                eprintln!("fixture setup panicked; retained={retained:?}");
1416                std::panic::resume_unwind(panic);
1417            }
1418        };
1419        let disk_ref = disk.endpoint().to_string();
1420        let movement_generation = ctx.data_movement_generation();
1421        let namespace_generation = store.scanner_namespace_mutation_generation();
1422        let read_options = crate::disk::ReadOptions {
1423            read_data: true,
1424            ..Default::default()
1425        };
1426        let mut tokens = Vec::new();
1427        let result = std::panic::AssertUnwindSafe(timeout(ttl / 2, async {
1428            let (old_token, _) = store
1429                .acquire_scanner_publication_lease(movement_generation, ttl)
1430                .await
1431                .expect("original lease");
1432            tokens.push(old_token);
1433            store
1434                .rename_local_data(&disk_ref, (user_volume, "staged"), &user_new, (user_volume, "destination"), None)
1435                .await
1436                .expect("ordinary namespace write");
1437            while ctx.namespace_commits_pending() {
1438                tokio::task::yield_now().await;
1439            }
1440            assert_eq!(ctx.namespace_commit_generation(), 2);
1441            assert_eq!(ctx.data_movement_generation(), movement_generation);
1442            let user_latest = disk
1443                .read_version(user_volume, user_volume, "destination", "", &read_options)
1444                .await
1445                .expect("latest ordinary committed object");
1446            assert_eq!(user_latest.version_id, user_new.version_id);
1447            assert_eq!(user_latest.data, user_new.data);
1448            assert!(
1449                store
1450                    .validate_scanner_publication_lease(old_token, movement_generation)
1451                    .await
1452                    .is_err()
1453            );
1454            assert_eq!(
1455                ctx.scanner_publication_lease_generations(old_token).await,
1456                Some((movement_generation, namespace_generation)),
1457                "rejection must not refresh or discard the old lease"
1458            );
1459            let (fresh_token, fresh_generation) = store
1460                .acquire_scanner_publication_lease(movement_generation, ttl)
1461                .await
1462                .expect("a new scan can acquire a current lease after the completed write");
1463            tokens.push(fresh_token);
1464            store
1465                .validate_scanner_publication_lease(fresh_token, fresh_generation)
1466                .await
1467                .expect("fresh lease validates");
1468            store
1469                .rename_local_data(
1470                    &disk_ref,
1471                    (metadata_volume, "staged"),
1472                    &metadata_new,
1473                    (metadata_volume, "destination"),
1474                    Some(fresh_token),
1475                )
1476                .await
1477                .expect("fresh lease authorizes real internal metadata publication");
1478            let latest = disk
1479                .read_version(metadata_volume, metadata_volume, "destination", "", &read_options)
1480                .await
1481                .expect("latest published metadata");
1482            let raw = tokio::fs::read(root.path().join(metadata_volume).join("destination/xl.meta"))
1483                .await
1484                .expect("raw published metadata");
1485            assert_eq!(latest.version_id, metadata_new.version_id);
1486            assert_eq!(latest.data, metadata_new.data);
1487            assert_ne!(raw, metadata_before);
1488            assert!(!ctx.namespace_commits_pending());
1489            assert_eq!(
1490                ctx.namespace_commit_generation(),
1491                2,
1492                "internal metadata does not mutate the user namespace"
1493            );
1494            assert_eq!(ctx.data_movement_generation(), movement_generation);
1495        }))
1496        .catch_unwind()
1497        .await;
1498        // A table release does not drain an independently owned metadata call.
1499        // Collect every release outcome before checking either ownership chain.
1500        let cleanup = std::panic::AssertUnwindSafe(async {
1501            let mut releases = Vec::new();
1502            for token in tokens {
1503                releases.push(
1504                    std::panic::AssertUnwindSafe(timeout(Duration::from_secs(5), store.release_scanner_publication_lease(token)))
1505                        .catch_unwind()
1506                        .await,
1507                );
1508            }
1509            let movement_guard = timeout(Duration::from_secs(5), ctx.data_movement_operation_gate().write_owned()).await;
1510            let namespace_drained = timeout(Duration::from_secs(5), async {
1511                while ctx.namespace_commits_pending() {
1512                    tokio::task::yield_now().await;
1513                }
1514            })
1515            .await;
1516            let drained = releases.iter().all(|release| matches!(release, Ok(Ok(_))))
1517                && movement_guard.is_ok()
1518                && namespace_drained.is_ok();
1519            #[cfg(not(windows))]
1520            let drained = {
1521                use crate::disk::os::prepared_publication_test_hooks as hooks;
1522
1523                let mut keys_drained = true;
1524                for volume in [user_volume, metadata_volume] {
1525                    // The physical lease uses the actual IO object directory,
1526                    // including descriptor-rooted aliases, not its xl.meta file.
1527                    let key_drained = match disk.get_object_path_for_io_if_local(volume, "destination") {
1528                        Some(Ok(path)) => timeout(Duration::from_secs(5), hooks::drain_namespace_key(&path))
1529                            .await
1530                            .is_ok(),
1531                        _ => false,
1532                    };
1533                    keys_drained &= key_drained;
1534                }
1535                drained && keys_drained
1536            };
1537            drop(movement_guard);
1538            if let Some(panic) = releases.into_iter().find_map(|release| release.err()) {
1539                std::panic::resume_unwind(panic);
1540            }
1541            drained
1542        })
1543        .catch_unwind()
1544        .await;
1545        // Generic cancelled IO cannot be proved drained by a namespace key.
1546        // Retain on any failed observation, even if best-effort cleanup succeeds.
1547        if !matches!(&result, Ok(Ok(()))) || !matches!(&cleanup, Ok(true)) {
1548            let retained = root.keep();
1549            eprintln!("fixture observations or physical cleanup incomplete; retained={retained:?}");
1550        }
1551        match result {
1552            Ok(result) => result.expect("publication must finish before the original lease can expire"),
1553            Err(panic) => std::panic::resume_unwind(panic),
1554        }
1555        match cleanup {
1556            Ok(drained) => assert!(drained, "fixture physical cleanup must finish before deleting its root"),
1557            Err(panic) => std::panic::resume_unwind(panic),
1558        }
1559        assert!(ctx.data_movement_operation_gate().try_write_owned().is_ok());
1560    }
1561
1562    #[cfg(not(windows))]
1563    #[tokio::test]
1564    #[serial_test::serial]
1565    async fn target_ordinary_timeout_keeps_its_physical_namespace_owner() {
1566        use crate::disk::os::prepared_publication_test_hooks as hooks;
1567        temp_env::async_with_vars([(rustfs_config::ENV_DRIVE_MAX_TIMEOUT_DURATION, Some("1"))], async {
1568            let ctx = Arc::new(InstanceContext::new());
1569            let store = super::super::tests::build_store_with_ctx(ctx.clone());
1570            let root = tempfile::tempdir().expect("root");
1571            let disk = target_disk(&ctx, root.path(), Uuid::new_v4()).await;
1572            let fi = target_file_info("destination", Uuid::new_v4(), b"timed-out-physical-commit");
1573            seed_target(&disk, "target-bucket", "staged", fi.clone()).await;
1574            let path = disk
1575                .get_object_path_for_io_if_local("target-bucket", "destination/xl.meta")
1576                .expect("local")
1577                .expect("destination IO path");
1578            let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
1579            let (release_tx, release_rx) = std::sync::mpsc::channel::<()>();
1580            let _hook = hooks::install(&path, move || {
1581                let _ = entered_tx.send(());
1582                let _ = release_rx.recv();
1583            });
1584            let disk_ref = disk.endpoint().to_string();
1585            let mut rename = Box::pin(store.rename_local_data(
1586                &disk_ref,
1587                ("target-bucket", "staged"),
1588                &fi,
1589                ("target-bucket", "destination"),
1590                None,
1591            ));
1592            tokio::time::timeout(std::time::Duration::from_secs(10), async {
1593                tokio::select! {
1594                    result = &mut rename => panic!("completed before physical pause: {result:?}"),
1595                    entered = entered_rx => entered.expect("physical entry"),
1596                }
1597            })
1598            .await
1599            .expect("bounded entry");
1600            tokio::time::pause();
1601            tokio::time::advance(std::time::Duration::from_secs(2)).await;
1602            tokio::time::resume();
1603            let result = tokio::time::timeout(std::time::Duration::from_secs(5), &mut rename)
1604                .await
1605                .expect("ordinary deadline remains enabled");
1606            assert!(matches!(result, Err(DiskError::Timeout)), "{result:?}");
1607            drop(rename);
1608            assert!(ctx.namespace_commits_pending(), "timeout is not a physical drain");
1609            drop(release_tx);
1610            tokio::time::timeout(std::time::Duration::from_secs(10), async {
1611                while ctx.namespace_commits_pending() {
1612                    tokio::task::yield_now().await;
1613                }
1614            })
1615            .await
1616            .expect("late physical owner drains");
1617            let read = disk
1618                .read_version(
1619                    "target-bucket",
1620                    "target-bucket",
1621                    "destination",
1622                    &fi.version_id.expect("version").to_string(),
1623                    &crate::disk::ReadOptions {
1624                        read_data: true,
1625                        ..Default::default()
1626                    },
1627                )
1628                .await
1629                .expect("read actual timeout tail");
1630            assert_eq!(read.data, fi.data);
1631        })
1632        .await;
1633    }
1634
1635    #[test]
1636    fn endpoint_rpc_authority_preserves_port_and_ipv6_brackets() {
1637        let endpoint = Endpoint::try_from("https://127.0.0.1:9001/d1").expect("URL endpoint");
1638        assert_eq!(endpoint_rpc_authority(&endpoint).as_deref(), Some("127.0.0.1:9001"));
1639
1640        let endpoint = Endpoint::try_from("https://[::1]:9002/d1").expect("IPv6 URL endpoint");
1641        assert_eq!(endpoint_rpc_authority(&endpoint).as_deref(), Some("[::1]:9002"));
1642    }
1643
1644    #[tokio::test]
1645    #[serial_test::serial]
1646    async fn init_local_peer_publishes_complete_rpc_authority() {
1647        let previous = rustfs_common::get_global_local_node_name().await;
1648        let mut endpoint = Endpoint::try_from("https://127.0.0.1:9001/d1").expect("URL endpoint");
1649        endpoint.is_local = true;
1650        let endpoint_pools = EndpointServerPools(vec![PoolEndpoints {
1651            legacy: false,
1652            set_count: 1,
1653            drives_per_set: 1,
1654            endpoints: Endpoints::from(vec![endpoint]),
1655            cmd_line: "rpc-authority-test".to_string(),
1656            platform: "test".to_string(),
1657        }]);
1658
1659        let host = String::new();
1660        let port = "9000".to_string();
1661        init_local_peer(&endpoint_pools, &host, &port).await;
1662        assert_eq!(rustfs_common::try_get_global_local_node_name().as_deref(), Some("127.0.0.1:9001"));
1663        rustfs_common::set_global_local_node_name(&previous).await;
1664    }
1665
1666    // Phase 5 follow-up (backlog#1052): registering local disks through the
1667    // ctx-explicit entry writes the passed context's registry only — the
1668    // process bootstrap context (and any other instance) stays clean, so a
1669    // future second server's disks cannot leak into the first one's registry.
1670    #[tokio::test]
1671    async fn init_local_disks_with_instance_ctx_isolates_disk_registry() {
1672        let temp_dir = tempfile::tempdir().expect("create temp disk dir");
1673        let endpoint_pools = single_local_disk_pools(temp_dir.path());
1674        let instance_ctx = Arc::new(InstanceContext::new());
1675
1676        init_local_disks_with_instance_ctx(&instance_ctx, endpoint_pools)
1677            .await
1678            .expect("local disks should register into the passed context");
1679
1680        let registered: Vec<String> = instance_ctx.local_disk_map().read().await.keys().cloned().collect();
1681        assert_eq!(registered.len(), 1, "the passed context must hold exactly the one local disk");
1682        assert_eq!(
1683            instance_ctx.local_disk_set_drives().read().await.len(),
1684            1,
1685            "the passed context must hold the pool/set/drive layout"
1686        );
1687
1688        let bootstrap = crate::runtime::instance::bootstrap_ctx();
1689        let bootstrap_map = bootstrap.local_disk_map();
1690        let bootstrap_map = bootstrap_map.read().await;
1691        let sibling = InstanceContext::new();
1692        for key in &registered {
1693            assert!(
1694                !bootstrap_map.contains_key(key),
1695                "bootstrap context must not absorb a disk registered into an explicit context"
1696            );
1697            assert!(
1698                !sibling.local_disk_map().read().await.contains_key(key),
1699                "a sibling context must not observe another instance's disks"
1700            );
1701        }
1702    }
1703
1704    #[tokio::test]
1705    async fn stale_local_disk_snapshot_cannot_repopulate_the_id_registry() {
1706        let temp_dir = tempfile::tempdir().expect("create temp disk dir");
1707        let endpoint_pools = single_local_disk_pools(temp_dir.path());
1708        let instance_ctx = Arc::new(InstanceContext::new());
1709        init_local_disks_with_instance_ctx(&instance_ctx, endpoint_pools)
1710            .await
1711            .expect("local disk should be registered");
1712        let disk = instance_ctx
1713            .local_disk_map()
1714            .read()
1715            .await
1716            .values()
1717            .find_map(|disk| disk.clone())
1718            .expect("registered local disk");
1719        let endpoint = disk.endpoint().to_string();
1720        let disk_id = Uuid::new_v4();
1721
1722        let local_disk_map = instance_ctx.local_disk_map();
1723        let mut quarantine = local_disk_map.write().await;
1724        let replacement = new_disk(
1725            &disk.endpoint(),
1726            &DiskOption {
1727                cleanup: false,
1728                health_check: false,
1729            },
1730        )
1731        .await
1732        .expect("replacement disk should initialize");
1733        assert!(!Arc::ptr_eq(&disk, &replacement));
1734        let task_ctx = instance_ctx.clone();
1735        let task_disk = disk.clone();
1736        let remember = tokio::spawn(async move { record_local_disk_id_if_active(&task_ctx, &task_disk, disk_id).await });
1737        tokio::task::yield_now().await;
1738        quarantine.insert(endpoint.clone(), Some(replacement.clone()));
1739        drop(quarantine);
1740
1741        assert!(!remember.await.expect("stale lookup task should complete"));
1742        assert!(!instance_ctx.local_disk_id_map().read().await.contains_key(&disk_id));
1743        let active = instance_ctx
1744            .local_disk_map()
1745            .read()
1746            .await
1747            .get(&endpoint)
1748            .cloned()
1749            .flatten()
1750            .expect("replacement disk should remain registered");
1751        assert!(Arc::ptr_eq(&active, &replacement));
1752        assert!(record_local_disk_id_if_active(&instance_ctx, &replacement, disk_id).await);
1753        assert_eq!(instance_ctx.local_disk_id_map().read().await.get(&disk_id), Some(&endpoint));
1754    }
1755}