@@ -567,6 +567,35 @@ struct SandboxRecord {
567567 deleting : bool ,
568568}
569569
570+ /// Resolve a lifecycle request to a registry key.
571+ ///
572+ /// A non-empty `sandbox_id` is authoritative: resolution uses that id alone and
573+ /// never falls back to the name, so a request for an already-removed sandbox
574+ /// reports absence instead of matching a same-named sandbox in another
575+ /// workspace. Only a caller that supplies no id resolves by name, and because
576+ /// sandbox names are unique per workspace rather than globally, a name matching
577+ /// more than one record is rejected instead of decided by iteration order.
578+ fn resolve_record_id (
579+ registry : & HashMap < String , SandboxRecord > ,
580+ sandbox_id : & str ,
581+ sandbox_name : & str ,
582+ ) -> Result < Option < String > , Status > {
583+ if !sandbox_id. is_empty ( ) {
584+ return Ok ( registry. get_key_value ( sandbox_id) . map ( |( id, _) | id. clone ( ) ) ) ;
585+ }
586+
587+ let mut matches = registry
588+ . iter ( )
589+ . filter ( |( _, record) | record. snapshot . name == sandbox_name) ;
590+ let first = matches. next ( ) . map ( |( id, _) | id. clone ( ) ) ;
591+ if matches. next ( ) . is_some ( ) {
592+ return Err ( Status :: failed_precondition ( format ! (
593+ "sandbox_name {sandbox_name} matched more than one sandbox; supply sandbox_id"
594+ ) ) ) ;
595+ }
596+ Ok ( first)
597+ }
598+
570599#[ derive( Debug , Clone , Copy , PartialEq , Eq ) ]
571600enum OverlayPreparation {
572601 Fresh ,
@@ -1389,14 +1418,7 @@ impl VmDriver {
13891418 }
13901419 let record_id = {
13911420 let registry = self . registry . lock ( ) . await ;
1392- if registry. contains_key ( sandbox_id) {
1393- Some ( sandbox_id. to_string ( ) )
1394- } else {
1395- registry
1396- . iter ( )
1397- . find ( |( _, record) | record. snapshot . name == sandbox_name)
1398- . map ( |( id, _) | id. clone ( ) )
1399- }
1421+ resolve_record_id ( & registry, sandbox_id, sandbox_name) ?
14001422 }
14011423 . ok_or_else ( || Status :: not_found ( "sandbox not found" ) ) ?;
14021424
@@ -1463,16 +1485,13 @@ impl VmDriver {
14631485 }
14641486 let ( record_id, state_dir, already_running) = {
14651487 let registry = self . registry . lock ( ) . await ;
1466- let ( id, record) = if let Some ( entry) = registry. get_key_value ( sandbox_id) {
1467- entry
1468- } else {
1469- registry
1470- . iter ( )
1471- . find ( |( _, record) | record. snapshot . name == sandbox_name)
1472- . ok_or_else ( || Status :: not_found ( "sandbox not found" ) ) ?
1473- } ;
1488+ let id = resolve_record_id ( & registry, sandbox_id, sandbox_name) ?
1489+ . ok_or_else ( || Status :: not_found ( "sandbox not found" ) ) ?;
1490+ let record = registry
1491+ . get ( & id)
1492+ . ok_or_else ( || Status :: not_found ( "sandbox not found" ) ) ?;
14741493 (
1475- id. clone ( ) ,
1494+ id,
14761495 record. state_dir . clone ( ) ,
14771496 record. process . is_some ( ) || record. provisioning_task . is_some ( ) ,
14781497 )
@@ -1528,14 +1547,7 @@ impl VmDriver {
15281547
15291548 let record_id = {
15301549 let registry = self . registry . lock ( ) . await ;
1531- if let Some ( ( id, _record) ) = registry. get_key_value ( sandbox_id) {
1532- Some ( id. clone ( ) )
1533- } else {
1534- registry
1535- . iter ( )
1536- . find ( |( _, record) | record. snapshot . name == sandbox_name)
1537- . map ( |( id, _) | id. clone ( ) )
1538- }
1550+ resolve_record_id ( & registry, sandbox_id, sandbox_name) ?
15391551 } ;
15401552
15411553 let Some ( record_id) = record_id else {
@@ -10227,4 +10239,185 @@ mod tests {
1022710239 assert ! ( gpu. default_selection_supported) ;
1022810240 assert ! ( gpu. count_selection_supported) ;
1022910241 }
10242+
10243+ /// Register a stopped, process-free record whose id, name, and workspace are
10244+ /// set independently.
10245+ ///
10246+ /// The other test helpers reuse one string for both id and name, so a test
10247+ /// built on them cannot express the cross-workspace name collision that
10248+ /// lifecycle resolution has to tolerate.
10249+ async fn insert_named_record (
10250+ driver : & VmDriver ,
10251+ id : & str ,
10252+ name : & str ,
10253+ workspace : & str ,
10254+ ) -> PathBuf {
10255+ let state_dir = sandbox_state_dir ( & driver. config . state_dir , id) . unwrap ( ) ;
10256+ create_private_dir_all ( & state_dir) . await . unwrap ( ) ;
10257+ driver. registry . lock ( ) . await . insert (
10258+ id. to_string ( ) ,
10259+ SandboxRecord {
10260+ snapshot : Sandbox {
10261+ id : id. to_string ( ) ,
10262+ name : name. to_string ( ) ,
10263+ workspace : workspace. to_string ( ) ,
10264+ ..Default :: default ( )
10265+ } ,
10266+ state_dir : state_dir. clone ( ) ,
10267+ process : None ,
10268+ provisioning_task : None ,
10269+ gpu_bdf : None ,
10270+ qemu_network_allocated : false ,
10271+ deleting : false ,
10272+ } ,
10273+ ) ;
10274+ state_dir
10275+ }
10276+
10277+ fn resolution_test_driver ( state_dir : & Path ) -> VmDriver {
10278+ let mut driver = test_driver_with_extensions ( LifecycleExtensionRegistry :: new ( ) ) ;
10279+ driver. config . state_dir = state_dir. to_path_buf ( ) ;
10280+ driver
10281+ }
10282+
10283+ #[ tokio:: test]
10284+ async fn stop_targets_the_requested_id_when_two_workspaces_share_a_name ( ) {
10285+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10286+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10287+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10288+ let beta = insert_named_record ( & driver, "vm-beta" , "demo" , "beta" ) . await ;
10289+
10290+ driver
10291+ . stop_sandbox ( "vm-beta" , "demo" )
10292+ . await
10293+ . expect ( "stop by id should be accepted" ) ;
10294+
10295+ assert ! (
10296+ beta. join( SANDBOX_STOPPED_FILE ) . exists( ) ,
10297+ "the requested sandbox should have been stopped"
10298+ ) ;
10299+ assert ! (
10300+ !alpha. join( SANDBOX_STOPPED_FILE ) . exists( ) ,
10301+ "the same-named sandbox in another workspace must be untouched"
10302+ ) ;
10303+ }
10304+
10305+ #[ tokio:: test]
10306+ async fn delete_targets_the_requested_id_when_two_workspaces_share_a_name ( ) {
10307+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10308+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10309+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10310+ insert_named_record ( & driver, "vm-beta" , "demo" , "beta" ) . await ;
10311+
10312+ let response = driver
10313+ . delete_sandbox ( "vm-beta" , "demo" )
10314+ . await
10315+ . expect ( "delete by id should be accepted" ) ;
10316+
10317+ assert ! ( response. deleted) ;
10318+ let registry = driver. registry . lock ( ) . await ;
10319+ assert ! ( !registry. contains_key( "vm-beta" ) ) ;
10320+ assert ! (
10321+ registry. contains_key( "vm-alpha" ) ,
10322+ "the same-named sandbox in another workspace must survive"
10323+ ) ;
10324+ assert ! ( alpha. exists( ) , "the surviving sandbox must keep its state" ) ;
10325+ }
10326+
10327+ #[ tokio:: test]
10328+ async fn a_repeated_delete_does_not_fall_back_to_a_same_named_sandbox ( ) {
10329+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10330+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10331+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10332+ insert_named_record ( & driver, "vm-beta" , "demo" , "beta" ) . await ;
10333+
10334+ let first = driver
10335+ . delete_sandbox ( "vm-beta" , "demo" )
10336+ . await
10337+ . expect ( "the first delete should be accepted" ) ;
10338+ assert ! ( first. deleted) ;
10339+
10340+ // Delete is idempotent, so a retry carrying the same id and name is
10341+ // ordinary caller behavior. The id is gone from the registry by now, and
10342+ // resolving it by name instead would destroy the sandbox in `alpha`.
10343+ let second = driver
10344+ . delete_sandbox ( "vm-beta" , "demo" )
10345+ . await
10346+ . expect ( "a repeated delete should be accepted" ) ;
10347+
10348+ assert ! (
10349+ !second. deleted,
10350+ "a repeated delete must report that nothing was removed"
10351+ ) ;
10352+ assert ! (
10353+ driver. registry. lock( ) . await . contains_key( "vm-alpha" ) ,
10354+ "a repeated delete must not remove a same-named sandbox in another workspace"
10355+ ) ;
10356+ assert ! ( alpha. exists( ) , "the surviving sandbox must keep its state" ) ;
10357+ }
10358+
10359+ #[ tokio:: test]
10360+ async fn stop_and_start_reject_an_absent_id_that_shares_a_name ( ) {
10361+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10362+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10363+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10364+
10365+ let stop_error = driver
10366+ . stop_sandbox ( "vm-absent" , "demo" )
10367+ . await
10368+ . expect_err ( "a supplied id that is not registered must not resolve by name" ) ;
10369+ assert_eq ! ( stop_error. code( ) , Code :: NotFound ) ;
10370+
10371+ let start_error = driver
10372+ . start_sandbox ( "vm-absent" , "demo" )
10373+ . await
10374+ . expect_err ( "a supplied id that is not registered must not resolve by name" ) ;
10375+ assert_eq ! ( start_error. code( ) , Code :: NotFound ) ;
10376+
10377+ assert ! (
10378+ !alpha. join( SANDBOX_STOPPED_FILE ) . exists( ) ,
10379+ "the same-named sandbox must not have been touched"
10380+ ) ;
10381+ }
10382+
10383+ #[ tokio:: test]
10384+ async fn a_name_only_request_matching_two_sandboxes_is_rejected ( ) {
10385+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10386+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10387+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10388+ let beta = insert_named_record ( & driver, "vm-beta" , "demo" , "beta" ) . await ;
10389+
10390+ // Without an id the driver has nothing to disambiguate with: the request
10391+ // carries no workspace, and picking by iteration order would stop or
10392+ // delete an arbitrary one of the two.
10393+ for error in [
10394+ driver. stop_sandbox ( "" , "demo" ) . await . unwrap_err ( ) ,
10395+ driver. start_sandbox ( "" , "demo" ) . await . unwrap_err ( ) ,
10396+ driver. delete_sandbox ( "" , "demo" ) . await . unwrap_err ( ) ,
10397+ ] {
10398+ assert_eq ! ( error. code( ) , Code :: FailedPrecondition ) ;
10399+ assert ! ( error. message( ) . contains( "matched more than one sandbox" ) ) ;
10400+ }
10401+
10402+ let registry = driver. registry . lock ( ) . await ;
10403+ assert ! ( registry. contains_key( "vm-alpha" ) ) ;
10404+ assert ! ( registry. contains_key( "vm-beta" ) ) ;
10405+ assert ! ( !alpha. join( SANDBOX_STOPPED_FILE ) . exists( ) ) ;
10406+ assert ! ( !beta. join( SANDBOX_STOPPED_FILE ) . exists( ) ) ;
10407+ }
10408+
10409+ #[ tokio:: test]
10410+ async fn a_name_only_request_still_resolves_a_unique_name ( ) {
10411+ let temp = tempfile:: tempdir ( ) . unwrap ( ) ;
10412+ let driver = resolution_test_driver ( temp. path ( ) ) ;
10413+ let alpha = insert_named_record ( & driver, "vm-alpha" , "demo" , "alpha" ) . await ;
10414+ insert_named_record ( & driver, "vm-beta" , "other" , "beta" ) . await ;
10415+
10416+ driver
10417+ . stop_sandbox ( "" , "demo" )
10418+ . await
10419+ . expect ( "an unambiguous name-only stop should still resolve" ) ;
10420+
10421+ assert ! ( alpha. join( SANDBOX_STOPPED_FILE ) . exists( ) ) ;
10422+ }
1023010423}
0 commit comments