Skip to content

Commit 7d1c9b8

Browse files
committed
fix(driver-vm): resolve lifecycle requests on sandbox_id alone
Signed-off-by: Artem Lytvyn <[email protected]>
1 parent bcf96e4 commit 7d1c9b8

1 file changed

Lines changed: 218 additions & 25 deletions

File tree

‎crates/openshell-driver-vm/src/driver.rs‎

Lines changed: 218 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -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)]
571600
enum 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

Comments
 (0)