1use 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#[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 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 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 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
231async 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 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 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 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 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
398pub 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
430pub 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 if !first_local_client_set {
464 if let Err(e) = runtime_sources::set_primary_lock_client(local_client.clone()) {
465 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 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 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 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 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 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 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 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 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 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 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 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 #[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 ®istered {
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}