diff --git a/CLAUDE.md b/CLAUDE.md index a201f86..f3aae2c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -396,7 +396,14 @@ docker exec stdout → tokio task → emit("terminal-output-{sessionId}") → li every terminal's env and the files hold private keys). Repos clone in the background after the agent starts (terminals are usable before they arrive). Hybrid storage mounts EFS at `/mnt/triple-c-home` and symlinks `~/.claude`, `~/.claude.json`, `~/.ssh` into it (mounting over `/home/claude` would hide - the image's tooling); root never follows those links outside the mount (`aws_hybrid_ssh_dir`). On + the image's tooling); root never follows those links outside the mount (`aws_hybrid_ssh_dir`). EFS storage + is Hybrid plus a second access point (root `/triple-c-workspaces//`, a sibling of + the home roots) mounted straight at `/workspace`; the entrypoint links home state the same way + (`aws_storage_links_home`) and never creates or chowns `/workspace`. Because `/workspace` then + outlives the task, `clone_repos` marks a clone in progress in its own `.git/config` + (`triplec.cloning`) and redoes one a killed task left marked; a repo without the mark is skipped. + Switching EFS → Hybrid/Ephemeral keeps `workspace_access_point_id` (store-owned) until "Remove AWS + resources" with discard deletes both access points. On TERM the hook pushes unsaved work to a `triple-c/wip/` branch via a temporary index (the user's index is untouched; needs the task definition's `stopTimeout` raised, 120 s) unless the stop marker says the app handled it. The idle watcher runs as root under a supervisor and signals the diff --git a/app/src-tauri/src/aws/runtime.rs b/app/src-tauri/src/aws/runtime.rs index 8241292..8dc313b 100644 --- a/app/src-tauri/src/aws/runtime.rs +++ b/app/src-tauri/src/aws/runtime.rs @@ -18,7 +18,7 @@ use super::environments::{knowable, parse_environment_record, EnvironmentInfo, K use super::error::{classify_sdk_error, AwsError}; use super::tasks::{find_project_task, TaskApi, STOP_REASON}; use super::tofu_modules::{ - access_point_root, environment_cluster_name, environment_parameter_name, project_secret_name, task_family, + access_point_root, workspace_access_point_root, environment_cluster_name, environment_parameter_name, project_secret_name, task_family, user_file_system_token, user_role_names, }; use super::workspace::WorkspaceApi; @@ -234,15 +234,18 @@ pub struct RemoveRequest<'a> { /// missed it). pub stored_task_arn: Option<&'a str>, pub stored_access_point_id: Option<&'a str>, - /// Delete the EFS access point (ruling R9). The files stay on the - /// user's own file system (only their task role can read it) until - /// offboarding destroys it; a later start of the same project gets a new - /// access point onto the same directory. + /// The EFS-mode `/workspace` access point the store has (kept after a + /// switch to Hybrid or Ephemeral, Q1). + pub stored_workspace_access_point_id: Option<&'a str>, + /// Delete the EFS access points, home and `/workspace` (ruling R9). The + /// files stay on the user's own file system (only their task role can + /// read it) until offboarding destroys it; a later start of the same + /// project gets new access points onto the same directories. pub discard_data: bool, } /// Stop the project's task, delete its secret (no recovery window, R10) and, -/// with `discard_data`, delete its access point (not the files, R9). Task definition revisions +/// with `discard_data`, delete its access points (not the files, R9). Task definition revisions /// are left registered (R8). A task that can't be stopped stops the removal (nothing /// billed may be left running); the rest is attempted in full and every /// failure reported. @@ -288,20 +291,27 @@ pub async fn remove_workspace_resources = req.stored_access_point_id.map(String::from).into_iter().collect(); + let mut ids: Vec = [req.stored_access_point_id, req.stored_workspace_access_point_id] + .into_iter() + .flatten() + .map(String::from) + .collect(); let token = user_file_system_token(req.env, req.owner_key); match work.find_file_system(&token).await { Ok(Some(fs)) if fs.owner.as_deref() == Some(req.owner_user_id) => { - let root = access_point_root(req.owner_key, req.project_id); + let roots = [ + access_point_root(req.owner_key, req.project_id), + workspace_access_point_root(req.owner_key, req.project_id), + ]; match work.access_points(&fs.id).await { Ok(points) => ids.extend( points .into_iter() .filter(|a| { a.file_system_id == fs.id - && a.root_path.as_deref() == Some(root.as_str()) + && a.root_path.as_ref().is_some_and(|r| roots.contains(r)) && a.owner.as_deref() == Some(req.owner_user_id) && a.project.as_deref() == Some(req.project_id) }) diff --git a/app/src-tauri/src/aws/runtime/tests.rs b/app/src-tauri/src/aws/runtime/tests.rs index 7c9111c..53c5dd4 100644 --- a/app/src-tauri/src/aws/runtime/tests.rs +++ b/app/src-tauri/src/aws/runtime/tests.rs @@ -5,7 +5,7 @@ use aws_sdk_ecs::operation::run_task::RunTaskInput; use super::*; use crate::aws::tasks::TaskInfo; -use crate::aws::tofu_modules::owner_key; +use crate::aws::tofu_modules::{owner_key, workspace_access_point_root}; use crate::aws::workspace::{AccessPointRef, FileSystemRef, TaskDefinitionRef}; const REGION: &str = "eu-west-1"; @@ -288,6 +288,7 @@ async fn removal_stops_the_task_leaves_the_revisions_and_schedules_the_secret() project_id: PROJECT, stored_task_arn: Some(&t0), stored_access_point_id: Some("fsap-stored"), + stored_workspace_access_point_id: None, discard_data: false, }; remove_workspace_resources(&fake, &fake, &fake, &r).await.unwrap(); @@ -323,9 +324,65 @@ async fn a_failed_step_is_reported_but_the_rest_still_runs() { project_id: PROJECT, stored_task_arn: None, stored_access_point_id: Some("fsap-1"), + stored_workspace_access_point_id: None, discard_data: true, }; let e = remove_workspace_resources(&fake, &fake, &fake, &r).await.unwrap_err(); assert!(e.to_string().contains("secret"), "{e}"); assert!(fake.calls().contains(&"delete-ap fsap-1".to_string())); } + +#[tokio::test] +async fn removal_with_discard_deletes_both_access_points_and_without_keeps_both() { + let ap = |id: &str, root: String| AccessPointRef { + id: id.into(), + file_system_id: "fs-1".into(), + root_path: Some(root), + owner: Some(USER.into()), + project: Some(PROJECT.into()), + state: Some("available".into()), + }; + let points = vec![ + ap("fsap-home", access_point_root(&ok(), PROJECT)), + ap("fsap-ws", workspace_access_point_root(&ok(), PROJECT)), + AccessPointRef { + owner: Some("AROAOTHER:mallory".into()), + ..ap("fsap-foreign", workspace_access_point_root(&ok(), PROJECT)) + }, + AccessPointRef { + project: Some("another".into()), + ..ap("fsap-other-project", workspace_access_point_root(&ok(), PROJECT)) + }, + ]; + let key = ok(); + let mut r = RemoveRequest { + env: "dev", + region: REGION, + owner_user_id: USER, + owner_key: &key, + project_id: PROJECT, + stored_task_arn: None, + stored_access_point_id: Some("fsap-home"), + // Kept in the store after switching EFS -> Hybrid. + stored_workspace_access_point_id: Some("fsap-ws-stored"), + discard_data: false, + }; + let keep = Fake { access_points: points.clone(), ..Default::default() }; + remove_workspace_resources(&keep, &keep, &keep, &r).await.unwrap(); + assert!( + keep.calls().iter().all(|c| !c.starts_with("delete-ap")), + "{:?}", + keep.calls() + ); + + r.discard_data = true; + let discard = Fake { access_points: points, ..Default::default() }; + remove_workspace_resources(&discard, &discard, &discard, &r).await.unwrap(); + let mut deleted: Vec = discard + .calls() + .into_iter() + .filter_map(|c| c.strip_prefix("delete-ap ").map(String::from)) + .collect(); + deleted.sort(); + assert_eq!(deleted, vec!["fsap-home", "fsap-ws", "fsap-ws-stored"]); +} diff --git a/app/src-tauri/src/aws/tofu_modules.rs b/app/src-tauri/src/aws/tofu_modules.rs index 8528206..09ebece 100644 --- a/app/src-tauri/src/aws/tofu_modules.rs +++ b/app/src-tauri/src/aws/tofu_modules.rs @@ -202,6 +202,17 @@ pub fn access_point_root(owner_key: &str, project_id: &str) -> String { format!("/triple-c/{owner_key}/{}", project_component(project_id)) } +/// The root of the project's EFS-mode `/workspace` access point (Q1): +/// `/triple-c-workspaces//`, a sibling tree of the home +/// roots (under [`access_point_root`] it would sit inside the home access +/// point). At most 100 characters. +pub fn workspace_access_point_root(owner_key: &str, project_id: &str) -> String { + format!( + "/triple-c-workspaces/{owner_key}/{}", + project_component(project_id) + ) +} + /// The container's `awslogs-stream-prefix`; ECS names the stream /// `/workspace/`. pub fn log_stream_prefix(owner_key: &str, project_id: &str) -> String { diff --git a/app/src-tauri/src/aws/workspace.rs b/app/src-tauri/src/aws/workspace.rs index 9c1f1f9..630494d 100644 --- a/app/src-tauri/src/aws/workspace.rs +++ b/app/src-tauri/src/aws/workspace.rs @@ -1,5 +1,6 @@ //! A project's AWS resources, made ready before its task runs: the project -//! secret, the EFS access point (Hybrid storage) and the task definition. +//! secret, the EFS access points (Hybrid: home; EFS: home and `/workspace`) +//! and the task definition. //! //! **Everything project-shaped goes in the secret (P1).** Every workspace user //! has `ecs:Describe*` on `*`, so a task definition's `environment`, tags and @@ -43,7 +44,7 @@ use super::error::{classify_sdk_error, AwsError}; use super::identity::CallerIdentity; use super::tofu_modules::{ access_point_root, log_stream_prefix, owner_key, project_secret_name, task_family, - user_file_system_token, user_role_names, + user_file_system_token, user_role_names, workspace_access_point_root, }; use crate::host::ssm::AGENT_PORT; use crate::models::project::{validate_aws_workspace, Arch, RepoSource, StorageMode}; @@ -59,6 +60,9 @@ pub const CONTAINER_NAME: &str = "workspace"; /// Where a Hybrid project's access point is mounted (P4). pub const HOME_MOUNT_PATH: &str = "/mnt/triple-c-home"; const HOME_VOLUME: &str = "home"; +/// Where an EFS-mode project's second access point is mounted (Q1). +pub const WORKSPACE_MOUNT_PATH: &str = "/workspace"; +const WORKSPACE_VOLUME: &str = "workspace"; /// Secrets Manager's `SecretString` limit. pub const MAX_SECRET_BYTES: usize = 65_536; /// At most this many of a family's newest revisions are described when @@ -184,7 +188,7 @@ fn payload_map( match storage { StorageMode::Ephemeral => "ephemeral", StorageMode::Hybrid => "hybrid", - StorageMode::Efs => "efs", // Task 3 + StorageMode::Efs => "efs", } .into(), ); @@ -212,7 +216,7 @@ fn serialize_payload(m: &BTreeMap) -> Result { /// The project secret's JSON (P1, R1): every env pair, then the payload's own /// keys (`TRIPLEC_AGENT_TOKEN`, `TRIPLEC_FILES` = `{"ssh/"|"ca/": base64}`, /// `TRIPLEC_REPOS`, `TRIPLEC_WIP_PUSH` = `1`/`0`, `TRIPLEC_IDLE_STOP_MINUTES` -/// when on, `TRIPLEC_STORAGE` = `ephemeral`/`hybrid`), keys sorted. Fails +/// when on, `TRIPLEC_STORAGE` = `ephemeral`/`hybrid`/`efs`), keys sorted. Fails /// when it would exceed 65,536 bytes. #[cfg_attr(not(test), allow(dead_code))] pub fn project_secret_payload( @@ -255,9 +259,11 @@ pub struct WorkspacePlan { pub secret_arn: String, /// Sorted (the payload's key order). pub secret_keys: Vec, - /// Both set for Hybrid, both `None` for Ephemeral. + /// Both set for Hybrid and EFS, both `None` for Ephemeral. pub file_system_id: Option, pub access_point_id: Option, + /// The `/workspace` access point; used only when `storage` is EFS. + pub workspace_access_point_id: Option, pub tags: Vec<(String, String)>, } @@ -328,7 +334,14 @@ pub fn task_definition_request(plan: &WorkspacePlan) -> RegisterTaskDefinitionIn fn build_request(plan: &WorkspacePlan) -> RegisterTaskDefinitionInput { const BUILT: &str = "every required field is set"; let hybrid = match (&plan.storage, &plan.file_system_id, &plan.access_point_id) { - (StorageMode::Hybrid | StorageMode::Efs, Some(fs), Some(ap)) => Some((fs, ap)), // Task 3: Efs adds /workspace + (StorageMode::Hybrid | StorageMode::Efs, Some(fs), Some(ap)) => Some((fs, ap)), + _ => None, + }; + // EFS = Hybrid + `/workspace` on its own access point. Hybrid and + // Ephemeral requests are exactly what they were before EFS mode (a + // test pins their fingerprints). + let workspace = match (&plan.storage, hybrid, &plan.workspace_access_point_id) { + (StorageMode::Efs, Some((fs, _)), Some(ap)) => Some((fs, ap)), _ => None, }; @@ -392,6 +405,15 @@ fn build_request(plan: &WorkspacePlan) -> RegisterTaskDefinitionInput { .build(), ); } + if workspace.is_some() { + container = container.mount_points( + MountPoint::builder() + .source_volume(WORKSPACE_VOLUME) + .container_path(WORKSPACE_MOUNT_PATH) + .read_only(false) + .build(), + ); + } let mut req = RegisterTaskDefinitionInput::builder() .family(&plan.family) @@ -422,29 +444,35 @@ fn build_request(plan: &WorkspacePlan) -> RegisterTaskDefinitionInput { .map(|(k, v)| Tag::builder().key(k).value(v).build()) .collect(), )); - if let Some((fs, ap)) = hybrid { - req = req.volumes( - Volume::builder() - .name(HOME_VOLUME) - .efs_volume_configuration( - EfsVolumeConfiguration::builder() - .file_system_id(fs) - .transit_encryption(EfsTransitEncryption::Enabled) - .authorization_config( - EfsAuthorizationConfig::builder() - .access_point_id(ap) - .iam(EfsAuthorizationConfigIam::Enabled) - .build(), - ) - .build() - .expect(BUILT), - ) - .build(), - ); + for (name, (fs, ap)) in [(HOME_VOLUME, hybrid), (WORKSPACE_VOLUME, workspace)] + .into_iter() + .filter_map(|(n, v)| v.map(|v| (n, v))) + { + req = req.volumes(efs_volume(name, fs, ap)); } req.build().expect(BUILT) } +/// An EFS volume through an access point, IAM-authorised, TLS in transit. +fn efs_volume(name: &str, fs: &str, ap: &str) -> Volume { + Volume::builder() + .name(name) + .efs_volume_configuration( + EfsVolumeConfiguration::builder() + .file_system_id(fs) + .transit_encryption(EfsTransitEncryption::Enabled) + .authorization_config( + EfsAuthorizationConfig::builder() + .access_point_id(ap) + .iam(EfsAuthorizationConfigIam::Enabled) + .build(), + ) + .build() + .expect("every required field is set"), + ) + .build() +} + // ---------------------------------------------------------------------- API #[derive(Debug, Clone, PartialEq)] @@ -593,12 +621,14 @@ pub struct PreparedWorkspace { /// Exact `family:revision`. pub task_definition_arn: String, pub access_point_id: Option, + /// EFS storage's `/workspace` access point. + pub workspace_access_point_id: Option, /// This start's token, already in the secret. pub agent_token: String, pub secret_arn: String, } -/// Make the project's secret, access point (Hybrid) and task definition +/// Make the project's secret, access points (Hybrid, EFS) and task definition /// ready. Everything that can be checked locally — placement, sizes, the /// payload's size and names — is checked before the first write. pub async fn prepare_workspace( @@ -652,10 +682,11 @@ pub async fn prepare_workspace( .map_err(other)?; let json = serialize_payload(&payload).map_err(other)?; - // Hybrid: the user's own file system, from their onboarding. - let (file_system_id, access_point_id) = match cfg.storage { - StorageMode::Ephemeral => (None, None), - StorageMode::Hybrid | StorageMode::Efs => { // Task 3: Efs adds the workspace access point + // Hybrid and EFS: the user's own file system, from their onboarding. + let (file_system_id, access_point_id, workspace_access_point_id) = match cfg.storage { + StorageMode::Ephemeral => (None, None, None), + StorageMode::Hybrid | StorageMode::Efs => { + let mode = if cfg.storage == StorageMode::Efs { "EFS" } else { "Hybrid" }; let token = user_file_system_token(&env.name, &ok); let fs = api .find_file_system(&token) @@ -663,19 +694,31 @@ pub async fn prepare_workspace( .filter(|fs| fs.owner.as_deref() == Some(who.user_id.as_str())) .ok_or_else(|| { other(format!( - "Your file system in environment \"{}\" was not found. Hybrid storage \ + "Your file system in environment \"{}\" was not found. {mode} storage \ needs it: ask an administrator to onboard you there, or use \ Ephemeral storage.", env.name )) })?; - let root = access_point_root(&ok, &project.id); let points = api.access_points(&fs.id).await?; - let ap = match pick_access_point(&points, &fs.id, &root, &who.user_id, &project.id) { - Some(a) => a.id.clone(), - None => api.create_access_point(&fs.id, &root, &tags).await?, + let ensure = |root: String| { + let found = pick_access_point(&points, &fs.id, &root, &who.user_id, &project.id) + .map(|a| a.id.clone()); + let (fs_id, tags) = (&fs.id, &tags); + async move { + match found { + Some(id) => Ok(id), + None => api.create_access_point(fs_id, &root, tags).await, + } + } }; - (Some(fs.id), Some(ap)) + let ap = ensure(access_point_root(&ok, &project.id)).await?; + let workspace_ap = if cfg.storage == StorageMode::Efs { + Some(ensure(workspace_access_point_root(&ok, &project.id)).await?) + } else { + None + }; + (Some(fs.id), Some(ap), workspace_ap) } }; @@ -703,6 +746,7 @@ pub async fn prepare_workspace( secret_keys: payload.keys().cloned().collect(), file_system_id, access_point_id: access_point_id.clone(), + workspace_access_point_id: workspace_access_point_id.clone(), tags, }; let fingerprint = workspace_fingerprint(&plan); @@ -729,6 +773,7 @@ pub async fn prepare_workspace( family: plan.family, task_definition_arn, access_point_id, + workspace_access_point_id, agent_token, secret_arn, }) diff --git a/app/src-tauri/src/aws/workspace/tests.rs b/app/src-tauri/src/aws/workspace/tests.rs index 1d83fc1..c774635 100644 --- a/app/src-tauri/src/aws/workspace/tests.rs +++ b/app/src-tauri/src/aws/workspace/tests.rs @@ -9,7 +9,7 @@ use crate::aws::environments::EnvironmentInfo; use crate::aws::identity::CallerIdentity; use crate::aws::tofu_modules::{ access_point_root, log_stream_prefix, owner_key, project_secret_name, task_family, - user_file_system_token, + user_file_system_token, workspace_access_point_root, }; use crate::models::project::{Arch, AwsPlacement, AwsWorkspaceConfig, RepoSource, StorageMode}; use crate::models::Project; @@ -96,8 +96,10 @@ fn sample_plan(storage: StorageMode) -> WorkspacePlan { "GIT_TOKEN".into(), "TRIPLEC_AGENT_TOKEN".into(), ], - file_system_id: (storage == StorageMode::Hybrid).then(|| "fs-0123abcd".to_string()), - access_point_id: (storage == StorageMode::Hybrid).then(|| "fsap-0123abcd".to_string()), + file_system_id: (storage != StorageMode::Ephemeral).then(|| "fs-0123abcd".to_string()), + access_point_id: (storage != StorageMode::Ephemeral).then(|| "fsap-0123abcd".to_string()), + workspace_access_point_id: (storage == StorageMode::Efs) + .then(|| "fsap-4567efab".to_string()), tags: workspace_tags(USER, PROJECT_ID, "dev"), } } @@ -113,6 +115,7 @@ fn names_use_owner_key_and_never_contain_a_colon() { access_point_root(&ok, PROJECT_ID), log_stream_prefix(&ok, PROJECT_ID), user_file_system_token("dev", &ok), + workspace_access_point_root(&ok, PROJECT_ID), ]; for n in &names { assert!(n.contains(&ok), "{n} lacks the owner key"); @@ -125,6 +128,9 @@ fn names_use_owner_key_and_never_contain_a_colon() { assert_eq!(names[3], format!("{ok}/{PROJECT_ID}")); // The onboarding module's `creation_token` (local.name). assert_eq!(names[4], format!("triple-c-dev-{ok}")); + // A sibling of the home roots, never inside one (Q1). + assert_eq!(names[5], format!("/triple-c-workspaces/{ok}/{PROJECT_ID}")); + assert!(!names[5].starts_with(&format!("{}/", names[2]))); } #[test] @@ -144,6 +150,12 @@ fn names_sanitise_a_hostile_project_id() { !tail.is_empty() && !tail.contains('/') && tail != "." && tail != "..", "{root}" ); + let wroot = workspace_access_point_root(&ok, id); + assert_eq!( + wroot.strip_prefix(&format!("/triple-c-workspaces/{ok}/")), + Some(tail), + "{wroot}" + ); let secret = project_secret_name("dev", &ok, id); assert!(!secret.contains(':') && !secret.contains(".."), "{secret}"); assert_eq!(secret.matches('/').count(), 3, "{secret}"); @@ -151,6 +163,7 @@ fn names_sanitise_a_hostile_project_id() { let long = "x".repeat(500); assert!(task_family("abcdefghijklmnopqrst", &ok, &long).len() <= 255); assert!(access_point_root(&ok, &long).len() <= 100); + assert!(workspace_access_point_root(&ok, &long).len() <= 100); } // ------------------------------------------------------- task definition @@ -311,6 +324,84 @@ fn hybrid_mounts_the_access_point_with_iam_and_tls() { assert_eq!(mounts[0].read_only(), Some(false)); } +/// Captured before EFS mode existed: Hybrid and Ephemeral requests must not +/// change (a changed fingerprint registers a new revision for every project). +#[test] +fn hybrid_and_ephemeral_requests_are_unchanged_by_efs_mode() { + assert_eq!( + workspace_fingerprint(&sample_plan(StorageMode::Hybrid)), + "d6d00b3f3489060c40ff732be8eb8a10e723e26dd5f1ff58345e4c2a307f862d" + ); + assert_eq!( + workspace_fingerprint(&sample_plan(StorageMode::Ephemeral)), + "00f248ed315167fe7a1adc0ea5c8bcee328e8a0739a1c4f9ce9ac10270851786" + ); + // A stray workspace access point (kept after switching EFS → Hybrid) + // does not reach a Hybrid or Ephemeral request. + for storage in [StorageMode::Hybrid, StorageMode::Ephemeral] { + let mut p = sample_plan(storage); + p.workspace_access_point_id = Some("fsap-stray".into()); + assert_eq!( + workspace_fingerprint(&p), + workspace_fingerprint(&sample_plan(storage)) + ); + } +} + +#[test] +fn efs_mounts_home_and_workspace_access_points() { + let req = task_definition_request(&sample_plan(StorageMode::Efs)); + let vols = req.volumes(); + assert_eq!(vols.len(), 2); + let by_name = |n: &str| vols.iter().find(|v| v.name() == Some(n)).unwrap(); + for (name, ap) in [("home", "fsap-0123abcd"), ("workspace", "fsap-4567efab")] { + let efs = by_name(name).efs_volume_configuration().unwrap(); + assert_eq!(efs.file_system_id(), "fs-0123abcd"); + assert_eq!(efs.transit_encryption(), Some(&EfsTransitEncryption::Enabled)); + let auth = efs.authorization_config().unwrap(); + assert_eq!(auth.access_point_id(), Some(ap)); + assert_eq!(auth.iam(), Some(&EfsAuthorizationConfigIam::Enabled)); + assert!(efs.root_directory().is_none() || efs.root_directory() == Some("/")); + } + let mounts: Vec<(&str, &str, Option)> = req.container_definitions()[0] + .mount_points() + .iter() + .map(|m| { + ( + m.source_volume().unwrap(), + m.container_path().unwrap(), + m.read_only(), + ) + }) + .collect(); + assert_eq!( + mounts, + vec![ + ("home", "/mnt/triple-c-home", Some(false)), + ("workspace", "/workspace", Some(false)), + ] + ); + // Its own fingerprint, and the workspace access point is covered. + let fp = workspace_fingerprint(&sample_plan(StorageMode::Efs)); + assert_ne!(fp, workspace_fingerprint(&sample_plan(StorageMode::Hybrid))); + let mut other = sample_plan(StorageMode::Efs); + other.workspace_access_point_id = Some("fsap-other".into()); + assert_ne!(workspace_fingerprint(&other), fp); +} + +#[test] +fn efs_without_its_workspace_access_point_mounts_nothing_at_workspace() { + // Not a plan `prepare_workspace` makes; the builder must not invent one. + let mut p = sample_plan(StorageMode::Efs); + p.workspace_access_point_id = None; + let req = task_definition_request(&p); + assert!(req + .container_definitions()[0] + .mount_points() + .iter() + .all(|m| m.container_path() != Some("/workspace"))); +} + #[test] fn arm64_sets_the_runtime_platform() { let mut plan = sample_plan(StorageMode::Ephemeral); @@ -912,6 +1003,93 @@ async fn an_existing_access_point_is_reused() { assert_eq!(fake2.created_access_points.lock().unwrap().len(), 1); } +#[tokio::test] +async fn efs_creates_both_access_points_then_reuses_them_by_root_owner_and_project() { + let fake = Fake::onboarded(); + let ok = owner_key(REGION, USER); + let tags = workspace_tags(USER, PROJECT_ID, "dev"); + let p = project(StorageMode::Efs); + let first = prepare(&fake, &p, &[]).await.unwrap(); + let created = fake.created_access_points.lock().unwrap().clone(); + assert_eq!( + created, + vec![ + ("fs-0123abcd".to_string(), access_point_root(&ok, PROJECT_ID), tags.clone()), + ( + "fs-0123abcd".to_string(), + workspace_access_point_root(&ok, PROJECT_ID), + tags.clone() + ), + ] + ); + assert_eq!(first.access_point_id.as_deref(), Some("fsap-new1")); + assert_eq!(first.workspace_access_point_id.as_deref(), Some("fsap-new2")); + { + let reg = fake.registered.lock().unwrap(); + let aps: Vec> = reg[0] + .volumes() + .iter() + .map(|v| { + v.efs_volume_configuration() + .unwrap() + .authorization_config() + .unwrap() + .access_point_id() + }) + .collect(); + assert_eq!(aps, vec![Some("fsap-new1"), Some("fsap-new2")]); + let secrets = fake.secrets.lock().unwrap(); + assert_eq!(payload_map(&secrets[0].2)["TRIPLEC_STORAGE"], "efs"); + } + + // The second start finds both (and is not fooled by decoys: another + // owner's, another project's, the home root, one being deleted). + let good = AccessPointRef { + id: "fsap-ws".into(), + file_system_id: "fs-0123abcd".into(), + root_path: Some(workspace_access_point_root(&ok, PROJECT_ID)), + owner: Some(USER.into()), + project: Some(PROJECT_ID.into()), + state: Some("available".into()), + }; + fake.access_points.lock().unwrap().extend([ + AccessPointRef { id: "fsap-foreign".into(), owner: Some(OTHER.into()), ..good.clone() }, + AccessPointRef { + id: "fsap-other-project".into(), + project: Some("another".into()), + ..good.clone() + }, + AccessPointRef { id: "fsap-deleting".into(), state: Some("deleting".into()), ..good.clone() }, + AccessPointRef { + id: "fsap-home".into(), + root_path: Some(access_point_root(&ok, PROJECT_ID)), + ..good.clone() + }, + good, + ]); + let second = prepare(&fake, &p, &[]).await.unwrap(); + assert_eq!(fake.created_access_points.lock().unwrap().len(), 2); + assert_eq!(second.access_point_id.as_deref(), Some("fsap-home")); + assert_eq!(second.workspace_access_point_id.as_deref(), Some("fsap-ws")); +} + +#[tokio::test] +async fn hybrid_never_creates_or_returns_a_workspace_access_point() { + let fake = Fake::onboarded(); + let out = prepare(&fake, &project(StorageMode::Hybrid), &[]).await.unwrap(); + assert!(out.workspace_access_point_id.is_none()); + assert_eq!(fake.created_access_points.lock().unwrap().len(), 1); + assert_eq!(fake.registered.lock().unwrap()[0].volumes().len(), 1); +} + +#[tokio::test] +async fn efs_without_the_users_file_system_fails_before_any_write() { + let fake = Fake::default(); + let err = prepare(&fake, &project(StorageMode::Efs), &[]).await.unwrap_err(); + assert!(err.to_string().contains("EFS storage"), "{err}"); + assert_eq!(fake.writes(), 0); +} + #[tokio::test] async fn ephemeral_touches_no_file_system() { let fake = Fake::default(); // no file system at all @@ -1124,3 +1302,4 @@ fn a_secret_pending_deletion_is_recognised() { assert!(msg.contains("scheduled for deletion"), "{msg}"); assert!(msg.contains("triple-c/dev/abc/p"), "{msg}"); } + diff --git a/app/src-tauri/src/commands/project_commands.rs b/app/src-tauri/src/commands/project_commands.rs index 1a89e8c..0f8b6ea 100644 --- a/app/src-tauri/src/commands/project_commands.rs +++ b/app/src-tauri/src/commands/project_commands.rs @@ -715,7 +715,7 @@ pub async fn remove_project( // An AWS project's task and resources go first, and a failure keeps the // project: its record is the only handle on a billed task and its - // secret. Its EFS access point goes only when asked (the files stay on the + // secret. Its EFS access points go only when asked (the files stay on the // user's own file system until offboarding). if let Some(project) = state.projects_store.get(&project_id).filter(|p| p.is_aws()) { let settings = state.settings_store.get(); @@ -1463,7 +1463,7 @@ async fn start_project_container_locked( // id stored above is the tunnel's endpoint URL, which is what the death // watch reports a stopped task as. if project.is_aws() { - if let Some((task_arn, access_point_id, task_definition_arn)) = + if let Some((task_arn, access_point_id, task_definition_arn, workspace_access_point_id)) = crate::host::tunnels::runtime(&project_id) { state.projects_store.set_aws_runtime( @@ -1471,7 +1471,7 @@ async fn start_project_container_locked( Some(task_arn), access_point_id, Some(task_definition_arn), - project.aws.as_ref().and_then(|a| a.workspace_access_point_id.clone()), // Task 3: from the start + workspace_access_point_id, )?; } } @@ -1699,24 +1699,37 @@ pub async fn remove_aws_resources( ProjectHost::for_project(&project) .remove_aws_resources(&project, &settings, discard_data) .await?; - state - .projects_store - .set_aws_runtime(&project_id, None, access_point_after_removal(&project, discard_data), None, None)?; + let (access_point_id, workspace_access_point_id) = + access_points_after_removal(&project, discard_data); + state.projects_store.set_aws_runtime( + &project_id, + None, + access_point_id, + None, + workspace_access_point_id, + )?; state .projects_store .get(&project_id) .ok_or_else(|| format!("Project {} not found", project_id)) } -/// The access point a removal leaves stored: kept when the saved files were -/// kept (it is still there, a later start reuses it and a later removal -/// with `discard_data` deletes it; and while it is stored the project can't -/// move away from it — [`validate_aws_update`]), gone when they were not. -fn access_point_after_removal(project: &Project, discard_data: bool) -> Option { - if discard_data { - return None; +/// The access points (home, EFS `/workspace`) a removal leaves stored: kept +/// when the saved files were kept (they are still there, a later start +/// reuses them and a later removal with `discard_data` deletes them; and +/// while one is stored the project can't move away from it — +/// [`validate_aws_update`]), gone when they were not. +fn access_points_after_removal( + project: &Project, + discard_data: bool, +) -> (Option, Option) { + match project.aws.as_ref() { + Some(a) if !discard_data => ( + a.access_point_id.clone(), + a.workspace_access_point_id.clone(), + ), + _ => (None, None), } - project.aws.as_ref().and_then(|a| a.access_point_id.clone()) } fn check_aws_resources_removable(project: &Project) -> Result<(), String> { @@ -2712,14 +2725,14 @@ mod tests { let hosts = vec![host("h1")]; let mut stored = aws_project(); stored.aws.as_mut().unwrap().access_point_id = Some("fsap-1".into()); - assert_eq!(access_point_after_removal(&stored, false), Some("fsap-1".into())); - assert_eq!(access_point_after_removal(&stored, true), None); + assert_eq!(access_points_after_removal(&stored, false), (Some("fsap-1".into()), None)); + assert_eq!(access_points_after_removal(&stored, true), (None, None)); // What the store holds after a keep-the-files removal still blocks a move. let mut after = stored.clone(); let a = after.aws.as_mut().unwrap(); a.task_arn = None; a.task_definition_arn = None; - a.access_point_id = access_point_after_removal(&stored, false); + a.access_point_id = access_points_after_removal(&stored, false).0; let mut local = after.clone(); local.host_id = None; local.aws_placement = None; @@ -2727,10 +2740,33 @@ mod tests { let e = validate_aws_update(&after, &local, &hosts).unwrap_err(); assert!(e.contains("access point"), "{e}"); // After a discarding removal it can move. - after.aws.as_mut().unwrap().access_point_id = access_point_after_removal(&stored, true); + after.aws.as_mut().unwrap().access_point_id = access_points_after_removal(&stored, true).0; assert!(validate_aws_update(&after, &local, &hosts).is_ok()); } + #[test] + fn a_removal_keeps_or_drops_both_access_points_together() { + let hosts = vec![host("h1")]; + // EFS switched to Hybrid: the /workspace access point is still stored. + let mut stored = aws_project(); + let a = stored.aws.as_mut().unwrap(); + a.access_point_id = Some("fsap-1".into()); + a.workspace_access_point_id = Some("fsap-w".into()); + assert_eq!( + access_points_after_removal(&stored, false), + (Some("fsap-1".into()), Some("fsap-w".into())) + ); + assert_eq!(access_points_after_removal(&stored, true), (None, None)); + // Kept: the stored /workspace access point alone still blocks a move. + let mut after = stored.clone(); + after.aws.as_mut().unwrap().access_point_id = None; + let mut local = after.clone(); + local.host_id = None; + local.aws_placement = None; + local.aws = None; + assert!(validate_aws_update(&after, &local, &hosts).is_err()); + } + #[test] fn a_project_with_aws_resources_cannot_be_moved_off_its_host() { let hosts = vec![host("h1"), host("h2")]; diff --git a/app/src-tauri/src/docker/aws_mode_tests.rs b/app/src-tauri/src/docker/aws_mode_tests.rs index 192f733..2ca92d1 100644 --- a/app/src-tauri/src/docker/aws_mode_tests.rs +++ b/app/src-tauri/src/docker/aws_mode_tests.rs @@ -273,6 +273,42 @@ fn link_persistent_home_without_the_mount_changes_nothing() { assert!(fs::symlink_metadata(home.join(".claude")).unwrap().is_dir()); } +#[test] +fn efs_storage_links_home_state_like_hybrid() { + let script = format!( + "{}\nfor m in hybrid efs ephemeral '' HYBRID efsx; do aws_storage_links_home \"$m\" && echo \"$m:yes\" || echo \"$m:no\"; done\n", + aws_blocks(&["aws_env", "aws_home"]) + ); + let out = bash(&script, &[], &[], &[]); + assert_eq!( + String::from_utf8_lossy(&out.stdout), + "hybrid:yes\nefs:yes\nephemeral:no\n:no\nHYBRID:no\nefsx:no\n" + ); + // The call site asks it, rather than testing for `hybrid` alone (an EFS + // task would otherwise get no home links at all). + let call = ENTRYPOINT + .lines() + .position(|l| l.trim_start().starts_with("link_persistent_home /home/claude")) + .unwrap(); + let above = ENTRYPOINT.lines().nth(call - 1).unwrap(); + assert_eq!( + above.trim(), + "if [ \"$triplec_aws\" = 1 ] && aws_storage_links_home \"${TRIPLEC_STORAGE:-}\"; then" + ); +} + +#[test] +fn efs_workspace_check_warns_only_when_workspace_is_not_mounted() { + let tmp = tempfile::tempdir().unwrap(); + let script = format!("{}\naws_efs_workspace_check \"$1\"; echo \"rc=$?\"\n", aws_blocks(&["aws_env", "aws_home"])); + let out = bash(&script, &[tmp.path()], &[], &[]); + assert!(text(&out).contains("is not mounted"), "{}", text(&out)); + assert!(text(&out).contains("rc=0"), "{}", text(&out)); + let out = bash(&script, &[Path::new("/proc")], &[], &[]); + assert!(!text(&out).contains("warning"), "{}", text(&out)); + assert!(text(&out).contains("rc=0"), "{}", text(&out)); +} + /// `write_claude_json` with the Hybrid mount at `/mnt`, in aws mode or not. fn write_claude_json(tmp: &Path, aws: bool) -> Output { let mnt = tmp.join("mnt"); @@ -426,6 +462,50 @@ fn clone_repos_clones_skips_existing_and_reports_failures_without_failing() { ); } +#[test] +fn clone_repos_on_a_persistent_workspace_skips_on_restart_and_redoes_a_clone_cut_short() { + // EFS storage: /workspace outlives the task, so the next start sees + // what the last one left. + let tmp = tempfile::tempdir().unwrap(); + let ws = tmp.path().join("workspace"); + fs::create_dir_all(&ws).unwrap(); + let remote = bare_remote(tmp.path(), "proj"); + let json = format!( + r#"[{{"url":"{r}","branch":null,"folder":"a"}},{{"url":"{r}","branch":null,"folder":"b"}}]"#, + r = remote.display() + ); + let script = format!("{}\nclone_repos \"$JSON\" \"$1\" \"$2\"\n", aws_blocks(&["aws_env", "aws_repos"])); + let run = |status: &Path| { + fs::create_dir_all(status).unwrap(); + let out = bash(&script, &[&ws, status], &[("JSON", &json)], &[]); + assert!(out.status.success(), "{}", text(&out)); + (text(&out), fs::read_to_string(status.join("repos")).unwrap()) + }; + let (_, first) = run(&tmp.path().join("s1")); + assert_eq!(first, "a\tcloning\na\tcloned\nb\tcloning\nb\tcloned\n"); + // A finished clone carries no in-progress mark. + for f in ["a", "b"] { + let o = Command::new("git") + .args(["config", "--file"]) + .arg(ws.join(f).join(".git/config")) + .args(["--get", "triplec.cloning"]) + .output() + .unwrap(); + assert!(!o.status.success(), "{f} still marked"); + } + + // The user's work in a, and b as a clone the last task was killed in + // the middle of (its mark still set, its checkout missing). + fs::write(ws.join("a/mine"), "work").unwrap(); + git(&ws.join("b"), &["config", "triplec.cloning", "1"]); + fs::remove_file(ws.join("b/README")).unwrap(); + let (log, second) = run(&tmp.path().join("s2")); + assert_eq!(second, "a\texists\nb\tcloning\nb\tcloned\n", "{log}"); + assert!(log.contains("cut short"), "{log}"); + assert_eq!(fs::read_to_string(ws.join("a/mine")).unwrap(), "work", "never touched"); + assert_eq!(fs::read_to_string(ws.join("b/README")).unwrap(), "hello"); +} + /// A stand-in `ssh` that records how it was called and fails. fn fake_ssh(dir: &Path) -> (std::path::PathBuf, std::path::PathBuf) { let log = dir.join("ssh-calls"); @@ -1196,6 +1276,7 @@ fn docker_mode_never_reaches_the_aws_blocks() { "aws_hybrid_ssh_dir", "aws_before_stop", "start_idle_watch", + "aws_efs_workspace_check", ]; let guarded = |s: &str| s.contains("\"$triplec_aws\" = 1"); let mut seen = 0; @@ -1211,7 +1292,10 @@ fn docker_mode_never_reaches_the_aws_blocks() { "unguarded call outside the aws blocks: {line}" ); } - assert_eq!(seen, 5, "the call sites: Hybrid link, Hybrid ~/.ssh, clone, idle watch, stop"); + assert_eq!( + seen, 6, + "the call sites: Hybrid/EFS link, EFS /workspace check, Hybrid ~/.ssh, clone, idle watch, stop" + ); // Clones start in the background *after* the agent: the app gives a // starting task's agent only seconds to answer. let pos = |needle: &str| { diff --git a/app/src-tauri/src/host/aws_host.rs b/app/src-tauri/src/host/aws_host.rs index aa2d73a..6900a3e 100644 --- a/app/src-tauri/src/host/aws_host.rs +++ b/app/src-tauri/src/host/aws_host.rs @@ -362,6 +362,8 @@ pub struct TaskRecord { pub task_arn: String, pub access_point_id: Option, pub task_definition_arn: Option, + /// EFS storage's `/workspace` access point. + pub workspace_access_point_id: Option, } /// A connected task. @@ -373,6 +375,8 @@ pub struct Started { /// The access point the task mounts (Hybrid). `None` when an existing /// task was attached to: the store's value stands. pub access_point_id: Option, + /// The `/workspace` access point (EFS), like `access_point_id`. + pub workspace_access_point_id: Option, /// This start ran the task (rather than attaching to a running one). pub created: bool, } @@ -433,13 +437,14 @@ pub async fn start_core t, Err(e) => return Err(with_log_tail(tasks, &logs, &task.arn, e.to_string()).await), }; - (task, token, None, false) + (task, token, None, None, false) } else { progress(PROGRESS_PREPARING); let prepared = prepare_workspace( @@ -461,7 +466,10 @@ pub async fn start_core store.set_aws_runtime( project_id, @@ -860,6 +881,8 @@ pub async fn remove_resources( project_id: &project.id, stored_task_arn: aws.and_then(|a| a.task_arn.as_deref()), stored_access_point_id: aws.and_then(|a| a.access_point_id.as_deref()), + stored_workspace_access_point_id: aws + .and_then(|a| a.workspace_access_point_id.as_deref()), discard_data, }, ) @@ -974,6 +997,7 @@ pub async fn reconcile_project( task_arn: t.arn.clone(), access_point_id: None, task_definition_arn: Some(t.task_definition_arn.clone()), + workspace_access_point_id: None, }), ); } @@ -1072,6 +1096,10 @@ async fn reattach( forward, endpoint: endpoint.clone(), access_point_id: project.aws.as_ref().and_then(|a| a.access_point_id.clone()), + workspace_access_point_id: project + .aws + .as_ref() + .and_then(|a| a.workspace_access_point_id.clone()), task_definition_arn: task.task_definition_arn.clone(), }; if !reattach_still_wanted(store, &project.id, &task.arn) { diff --git a/app/src-tauri/src/host/aws_host/tests.rs b/app/src-tauri/src/host/aws_host/tests.rs index 220934e..fb625c9 100644 --- a/app/src-tauri/src/host/aws_host/tests.rs +++ b/app/src-tauri/src/host/aws_host/tests.rs @@ -155,11 +155,11 @@ impl WorkspaceApi for Fake { async fn create_access_point( &self, _fs: &str, - _root: &str, + root: &str, _tags: &[(String, String)], ) -> Result { self.log("create-ap"); - Ok("fsap-new".into()) + Ok(if root.starts_with("/triple-c-workspaces/") { "fsap-ws" } else { "fsap-new" }.into()) } async fn put_project_secret( &self, @@ -309,6 +309,76 @@ async fn a_first_start_prepares_runs_waits_and_connects_in_that_order() { ); } +#[tokio::test] +async fn an_efs_start_waits_for_both_access_points_and_records_them() { + let p = aws_project(StorageMode::Efs); + let fake = Fake { run: Some(task(&p, "new", "RUNNING", true)), ..Default::default() }; + let w = who(); + let records = Mutex::new(Vec::new()); + let on_task = |r: Option<&TaskRecord>| records.lock().unwrap().push(r.cloned()); + let started = start_core(&fake, &fake, &fake, &fake, &inputs(&p, &w, &on_task), &|_| {}) + .await + .unwrap(); + assert_eq!(started.access_point_id.as_deref(), Some("fsap-new")); + assert_eq!(started.workspace_access_point_id.as_deref(), Some("fsap-ws")); + let calls = fake.calls(); + let pos = |c: &str| calls.iter().position(|x| x == c).unwrap_or_else(|| panic!("{c}: {calls:?}")); + assert!(pos("ap-state fsap-new") < pos("run"), "{calls:?}"); + assert!(pos("ap-state fsap-ws") < pos("run"), "{calls:?}"); + let recs = records.into_inner().unwrap(); + let rec = recs[0].as_ref().unwrap(); + assert_eq!(rec.access_point_id.as_deref(), Some("fsap-new")); + assert_eq!(rec.workspace_access_point_id.as_deref(), Some("fsap-ws")); + + // Hybrid waits for one and records none for /workspace. + let p = aws_project(StorageMode::Hybrid); + let fake = Fake { run: Some(task(&p, "new", "RUNNING", true)), ..Default::default() }; + let records = Mutex::new(Vec::new()); + let on_task = |r: Option<&TaskRecord>| records.lock().unwrap().push(r.cloned()); + let started = start_core(&fake, &fake, &fake, &fake, &inputs(&p, &w, &on_task), &|_| {}) + .await + .unwrap(); + assert_eq!(started.workspace_access_point_id, None); + assert!(!fake.called("ap-state fsap-ws")); + assert_eq!(records.into_inner().unwrap()[0].as_ref().unwrap().workspace_access_point_id, None); +} + +#[test] +fn switching_efs_to_hybrid_keeps_the_stored_workspace_access_point() { + let mut p = aws_project(StorageMode::Hybrid); + p.aws.as_mut().unwrap().workspace_access_point_id = Some("fsap-ws".into()); + let (_d, store) = store_with(&p); + // A Hybrid start knows no /workspace access point: the stored one stays. + record_task( + &store, + &p.id, + Some(&TaskRecord { + task_arn: "arn:t".into(), + access_point_id: Some("fsap-home".into()), + task_definition_arn: None, + workspace_access_point_id: None, + }), + ); + let a = store.get(&p.id).unwrap().aws.unwrap(); + assert_eq!(a.workspace_access_point_id.as_deref(), Some("fsap-ws")); + record_task(&store, &p.id, None); + let a = store.get(&p.id).unwrap().aws.unwrap(); + assert_eq!(a.workspace_access_point_id.as_deref(), Some("fsap-ws")); + // An EFS start records its own. + record_task( + &store, + &p.id, + Some(&TaskRecord { + task_arn: "arn:t2".into(), + access_point_id: None, + task_definition_arn: None, + workspace_access_point_id: Some("fsap-ws2".into()), + }), + ); + let a = store.get(&p.id).unwrap().aws.unwrap(); + assert_eq!(a.workspace_access_point_id.as_deref(), Some("fsap-ws2")); +} + #[tokio::test] async fn a_running_task_is_attached_with_its_own_token_and_nothing_is_rewritten() { let p = aws_project(StorageMode::Hybrid); @@ -666,7 +736,12 @@ fn a_start_records_its_task_and_keeps_the_stored_handles_it_does_not_know() { record_task( &store, &p.id, - Some(&TaskRecord { task_arn: "arn:t".into(), access_point_id: None, task_definition_arn: Some("arn:td:2".into()) }), + Some(&TaskRecord { + task_arn: "arn:t".into(), + access_point_id: None, + task_definition_arn: Some("arn:td:2".into()), + workspace_access_point_id: None, + }), ); let a = store.get(&p.id).unwrap().aws.unwrap(); assert_eq!((a.task_arn.as_deref(), a.access_point_id.as_deref(), a.task_definition_arn.as_deref()), @@ -720,7 +795,12 @@ fn the_log_task_is_the_stored_one_else_the_last_one_a_start_saw() { record_task( &store, &p.id, - Some(&TaskRecord { task_arn: "arn:first".into(), access_point_id: None, task_definition_arn: None }), + Some(&TaskRecord { + task_arn: "arn:first".into(), + access_point_id: None, + task_definition_arn: None, + workspace_access_point_id: None, + }), ); record_task(&store, &p.id, None); assert_eq!(log_task_arn(&p).as_deref(), Some("arn:first"), "a cleared ARN still has a log"); diff --git a/app/src-tauri/src/host/lifecycle.rs b/app/src-tauri/src/host/lifecycle.rs index df81e45..f1fdd5f 100644 --- a/app/src-tauri/src/host/lifecycle.rs +++ b/app/src-tauri/src/host/lifecycle.rs @@ -132,7 +132,7 @@ impl ProjectHost { /// AWS: stop the task and remove the project's resources — task /// definition revisions, the secret (deleted at once) and, only - /// with `discard_data`, the EFS access point (not its files). Docker: nothing (its state + /// with `discard_data`, the EFS access points, home and EFS-mode `/workspace` (not their files). Docker: nothing (its state /// goes with [`Self::discard_project_state`]). pub async fn remove_aws_resources( &self, diff --git a/app/src-tauri/src/host/tunnels.rs b/app/src-tauri/src/host/tunnels.rs index 99d4106..b989dbe 100644 --- a/app/src-tauri/src/host/tunnels.rs +++ b/app/src-tauri/src/host/tunnels.rs @@ -51,6 +51,8 @@ pub struct LiveTunnel { /// Runtime handles for the store (`set_aws_runtime`). pub access_point_id: Option, pub task_definition_arn: String, + /// EFS storage's `/workspace` access point. + pub workspace_access_point_id: Option, } /// Where an endpoint's task is: `(connection, region, cluster, task ARN)`. @@ -123,13 +125,15 @@ pub fn get_endpoint(project_id: &str) -> Option { lock().live.get(project_id).map(|t| t.endpoint.clone()) } -/// `(task ARN, access point id, task definition ARN)` of the project's tunnel. -pub fn runtime(project_id: &str) -> Option<(String, Option, String)> { +/// `(task ARN, access point id, task definition ARN, workspace access point +/// id)` of the project's tunnel. +pub fn runtime(project_id: &str) -> Option<(String, Option, String, Option)> { lock().live.get(project_id).map(|t| { ( t.task_arn.clone(), t.access_point_id.clone(), t.task_definition_arn.clone(), + t.workspace_access_point_id.clone(), ) }) } @@ -334,6 +338,7 @@ pub(crate) mod tests { endpoint: AgentEndpoint::loopback(port, "tok"), access_point_id: Some("fsap-1".into()), task_definition_arn: "arn:td:1".into(), + workspace_access_point_id: None, } } diff --git a/app/src/components/projects/ConfirmRemoveModal.test.tsx b/app/src/components/projects/ConfirmRemoveModal.test.tsx index e5b66d8..10eaa76 100644 --- a/app/src/components/projects/ConfirmRemoveModal.test.tsx +++ b/app/src/components/projects/ConfirmRemoveModal.test.tsx @@ -14,6 +14,14 @@ describe("ConfirmRemoveModal", () => { expect(onConfirm.mock.calls).toEqual([[{ discardData: false }], [{ discardData: true }]]); }); + it("says both access points go when the workspace kept /workspace on EFS", () => { + render( + , + ); + expect(screen.getByRole("checkbox", { name: /file-system access points/ })).toBeInTheDocument(); + expect(screen.getByText(/\/workspace/)).toBeInTheDocument(); + }); + it("offers no access-point choice for an Ephemeral AWS workspace", () => { const onConfirm = vi.fn(); render(); diff --git a/app/src/components/projects/ConfirmRemoveModal.tsx b/app/src/components/projects/ConfirmRemoveModal.tsx index df16a78..9c2d8dc 100644 --- a/app/src/components/projects/ConfirmRemoveModal.tsx +++ b/app/src/components/projects/ConfirmRemoveModal.tsx @@ -8,6 +8,8 @@ interface Props { aws?: boolean; /** AWS: the workspace may have an EFS access point (offers removing it). */ savedFiles?: boolean; + /** AWS: `/workspace` may be on EFS too (EFS storage, now or before). */ + workspaceFiles?: boolean; onConfirm: (opts: { discardData: boolean }) => void; onCancel: () => void; } @@ -19,6 +21,7 @@ export default function ConfirmRemoveModal({ projectName, aws = false, savedFiles = false, + workspaceFiles = false, onConfirm, onCancel, }: Props) { @@ -61,11 +64,12 @@ export default function ConfirmRemoveModal({ onChange={(e) => setDiscardData(e.target.checked)} /> - Also remove the workspace’s file-system access point + Also remove the workspace’s file-system access points - The saved files themselves (Claude login, history, SSH keys) stay on your own - EFS file system, readable only by your workspace role, until an administrator - offboards you. + The saved files themselves (Claude login, history, SSH keys + {workspaceFiles ? ", and the /workspace files" : ""}) stay on your own EFS file + system, readable only by your workspace role, until an administrator offboards + you. diff --git a/app/src/components/projects/home/ProjectHome.tsx b/app/src/components/projects/home/ProjectHome.tsx index 9f59a30..75b0152 100644 --- a/app/src/components/projects/home/ProjectHome.tsx +++ b/app/src/components/projects/home/ProjectHome.tsx @@ -11,7 +11,7 @@ import Button from "../../ui/Button"; import OverflowMenu from "../../ui/OverflowMenu"; import ConfirmRemoveModal, { ConfirmForgetAwsModal } from "../ConfirmRemoveModal"; import StopGuardModal from "../StopGuardModal"; -import { hasSavedFiles, isAwsProject } from "../../../lib/awsWorkspace"; +import { hasSavedFiles, hasWorkspaceFiles, isAwsProject } from "../../../lib/awsWorkspace"; import { AWS_CONNECTION_MISSING, type RemoveProjectOptions } from "../../../lib/types"; import ConfirmResetModal from "../ConfirmResetModal"; import MigrateContainerModal from "../MigrateContainerModal"; @@ -349,6 +349,7 @@ export default function ProjectHome({ projectId, active }: Props) { projectName={project.name} aws={aws} savedFiles={hasSavedFiles(project)} + workspaceFiles={hasWorkspaceFiles(project)} onCancel={() => setConfirmRemove(false)} onConfirm={({ discardData }) => { setConfirmRemove(false); diff --git a/app/src/components/projects/home/config/AwsConfig.test.tsx b/app/src/components/projects/home/config/AwsConfig.test.tsx index bdcca36..0c2388d 100644 --- a/app/src/components/projects/home/config/AwsConfig.test.tsx +++ b/app/src/components/projects/home/config/AwsConfig.test.tsx @@ -131,7 +131,55 @@ describe("HostSection", () => { p.aws = { ...p.aws!, storage: "ephemeral" }; renderHost(p); expect(screen.getByText(/Claude login and history are lost when the workspace stops/)).toBeInTheDocument(); - expect(screen.getByText(/EFS .* coming later/)).toBeInTheDocument(); + expect(screen.queryByText(/coming later/)).toBeNull(); + }); + + it("offers EFS storage with what it costs", async () => { + const p = awsProject(); + renderHost(p); + const efs = screen.getByRole("radio", { name: "EFS" }); + expect(efs).not.toBeDisabled(); + fireEvent.click(efs); + await waitFor(() => expect(save).toHaveBeenCalled()); + expect(save.mock.calls[0][0].aws.storage).toBe("efs"); + + p.aws = { ...p.aws!, storage: "efs" }; + renderHost(p); + expect( + screen.getByText("Everything in /workspace survives a stop; git and builds are slower over NFS"), + ).toBeInTheDocument(); + }); + + it("says /workspace files stay on their access point after switching away from EFS", () => { + const p = awsProject(); + p.aws = { + ...p.aws!, + storage: "hybrid", + workspace_access_point_id: "fsap-w", + task_arn: null, + task_definition_arn: null, + access_point_id: null, + }; + renderHost(p); + expect(screen.getByRole("note", { name: "EFS files kept" })).toHaveTextContent( + /\/workspace files .* stay on their access point until .*Remove AWS resources/, + ); + // It is an AWS resource: removable, and it keeps the project in place. + expect(screen.getByRole("button", { name: "Run on this machine instead" })).toHaveAttribute( + "aria-disabled", + "true", + ); + fireEvent.click(screen.getByRole("button", { name: "Remove AWS resources…" })); + const dialog = screen.getByRole("dialog"); + expect(within(dialog).getByRole("checkbox", { name: /access points/ })).toBeInTheDocument(); + expect(dialog).toHaveTextContent(/\/workspace/); + }); + + it("does not show the kept-files note on EFS or without a workspace access point", () => { + const p = awsProject(); + p.aws = { ...p.aws!, storage: "efs", workspace_access_point_id: "fsap-w" }; + renderHost(p); + expect(screen.queryByRole("note", { name: "EFS files kept" })).toBeNull(); }); it("saves repository edits on blur", async () => { diff --git a/app/src/components/projects/home/config/HostSection.tsx b/app/src/components/projects/home/config/HostSection.tsx index 45b530e..c910090 100644 --- a/app/src/components/projects/home/config/HostSection.tsx +++ b/app/src/components/projects/home/config/HostSection.tsx @@ -3,6 +3,7 @@ import type { AwsWorkspaceConfig, HostConnection, Project, RepoSource } from ".. import * as commands from "../../../../lib/tauri-commands"; import { useAppState } from "../../../../store/appState"; import { + EFS_HINT, EPHEMERAL_WARNING, FARGATE_CPUS, defaultAwsWorkspace, @@ -10,6 +11,7 @@ import { formatMemory, memoryError, hasSavedFiles, + hasWorkspaceFiles, memoryOptions, nearestMemory, } from "../../../../lib/awsWorkspace"; @@ -57,9 +59,19 @@ export default function HostSection({ project, save, disabled }: Props) { const saveAws = (patch: Partial) => save({ aws: { ...aws, ...patch } }); - const hasResources = !!(aws.task_arn || aws.access_point_id || aws.task_definition_arn); - // A removal that kept the saved files keeps their access point stored. - const onlyAccessPoint = !!aws.access_point_id && !aws.task_arn && !aws.task_definition_arn; + const hasResources = !!( + aws.task_arn || + aws.access_point_id || + aws.workspace_access_point_id || + aws.task_definition_arn + ); + // A removal that kept the saved files keeps their access points stored. + const onlyAccessPoint = + !!(aws.access_point_id || aws.workspace_access_point_id) && + !aws.task_arn && + !aws.task_definition_arn; + // Switched away from EFS: its /workspace files are still on their access point. + const keptWorkspaceFiles = aws.storage !== "efs" && !!aws.workspace_access_point_id; // Not `disabled` (which also allows Error): on AWS, Error can mean a live task. const stopped = project.status === "stopped"; @@ -196,11 +208,9 @@ export default function HostSection({ project, save, disabled }: Props) { segments={[ { value: "ephemeral", label: "Ephemeral", caution: true }, { value: "hybrid", label: "Hybrid" }, + { value: "efs", label: "EFS" }, ]} /> - - EFS (everything persists) — coming later - {aws.storage === "ephemeral" ? (

{EPHEMERAL_WARNING} Push your work to a remote before stopping.

+ ) : aws.storage === "efs" ? ( +

+ {EFS_HINT}. The Claude login, history and SSH keys are kept on EFS too. +

) : (

The Claude login, history and SSH keys are kept on EFS between starts; everything else, repositories included, starts fresh.

)} + {keptWorkspaceFiles && ( +

+ The /workspace files from when this project used EFS storage stay on their access + point until “Remove AWS resources” removes it (with the access points + option checked). Switching back to EFS picks them up again. +

+ )} {(id) => ( void save({ host_id: null, aws_placement: null, aws: null })} @@ -422,8 +451,11 @@ function RemoveAwsResourcesModal({ project, onClose }: { project: Project; onClo onChange={(e) => setDiscardData(e.target.checked)} /> - Also remove the workspace’s file-system access point + Also remove the workspace’s file-system access points + {hasWorkspaceFiles(project) + ? "Both go: the one for the saved home files and the one for /workspace. " + : ""} The files stay on your own EFS file system (only your workspace role can read them) until an administrator offboards you. Left unchecked, the access point stays too: the next start here reuses it, and the project can’t move to diff --git a/app/src/lib/awsWorkspace.test.ts b/app/src/lib/awsWorkspace.test.ts index 06a11e9..93c04a5 100644 --- a/app/src/lib/awsWorkspace.test.ts +++ b/app/src/lib/awsWorkspace.test.ts @@ -3,6 +3,7 @@ import { cleanRepos, defaultAwsWorkspace, hasSavedFiles, + hasWorkspaceFiles, environmentSelectable, memoryError, memoryOptions, @@ -78,4 +79,12 @@ describe("phase 6 settings", () => { expect(hasSavedFiles({ aws: { ...aws, storage: "ephemeral", workspace_access_point_id: "fsap-w" } })).toBe(true); expect(hasSavedFiles({ aws: { ...aws, storage: "ephemeral" } })).toBe(false); }); + + it("knows when /workspace files may be on EFS", () => { + const aws = defaultAwsWorkspace(); + expect(hasWorkspaceFiles({ aws: { ...aws, storage: "efs" } })).toBe(true); + expect(hasWorkspaceFiles({ aws: { ...aws, storage: "hybrid", workspace_access_point_id: "fsap-w" } })).toBe(true); + expect(hasWorkspaceFiles({ aws: { ...aws, storage: "hybrid" } })).toBe(false); + expect(hasWorkspaceFiles({ aws: null })).toBe(false); + }); }); diff --git a/app/src/lib/awsWorkspace.ts b/app/src/lib/awsWorkspace.ts index 692136c..9d401ad 100644 --- a/app/src/lib/awsWorkspace.ts +++ b/app/src/lib/awsWorkspace.ts @@ -129,6 +129,16 @@ export function hasSavedFiles(p: Pick): boolean { return a?.storage === "hybrid" || a?.storage === "efs" || !!a?.access_point_id || !!a?.workspace_access_point_id; } +/** Whether an AWS project may have `/workspace` files on EFS (EFS storage now, + * or its access point left from when it was). */ +export function hasWorkspaceFiles(p: Pick): boolean { + const a = p.aws; + return a?.storage === "efs" || !!a?.workspace_access_point_id; +} + +/** Shown with EFS storage selected. */ +export const EFS_HINT = "Everything in /workspace survives a stop; git and builds are slower over NFS"; + /** Hosts that only mean something on this machine or its Docker bridge. */ const LOCAL_HOSTS = /^(localhost|127(\.\d{1,3}){3}|0\.0\.0\.0|\[?::1\]?|host\.docker\.internal|172\.17\.0\.1)$/i; diff --git a/container/entrypoint.sh b/container/entrypoint.sh index 0063525..0c1268e 100644 --- a/container/entrypoint.sh +++ b/container/entrypoint.sh @@ -213,7 +213,9 @@ remap_uid_gid() { # ~/.claude volume. find /home/claude \( ! -user claude -o ! -group claude \) -exec chown -h claude:claude {} + -# ── AWS Hybrid storage: persisted home state (plan ruling P4) ─────────────── +# ── AWS Hybrid/EFS storage: persisted home state (plan ruling P4) ─────────── +# EFS storage is Hybrid plus /workspace on a second access point (mounted by +# the task definition straight at /workspace), so it gets the same home links. # A Hybrid workspace mounts its EFS access point (POSIX 1000:1000) at # /mnt/triple-c-home. Mounting it over /home/claude would hide the image's # Claude Code, cargo and uv — EFS has no Docker-volume "copy the image's @@ -276,10 +278,31 @@ aws_hybrid_ssh_dir() { [ ! -L "$triplec_home_mnt" ] && [ ! -L "$want" ] && [ -d "$want" ] || return 1 printf '%s' "$want" } + +# Whether storage mode $1 persists home state (Hybrid, and EFS = Hybrid + +# /workspace on EFS). +aws_storage_links_home() { + case "$1" in + hybrid|efs) return 0 ;; + esac + return 1 +} + +# EFS storage: /workspace is the access point itself (uid/gid 1000 enforced, +# root acts as 1000 there). Nothing here creates or chowns it; only says so +# when it is missing, since the files would then not survive a stop. +aws_efs_workspace_check() { + mountpoint -q "$1" 2>/dev/null \ + || echo "entrypoint: warning — EFS storage, but $1 is not mounted; its files will not persist" + return 0 +} # <<< aws_home -if [ "$triplec_aws" = 1 ] && [ "${TRIPLEC_STORAGE:-}" = hybrid ]; then +if [ "$triplec_aws" = 1 ] && aws_storage_links_home "${TRIPLEC_STORAGE:-}"; then link_persistent_home /home/claude "$triplec_home_mnt" claude:claude fi +if [ "$triplec_aws" = 1 ] && [ "${TRIPLEC_STORAGE:-}" = efs ]; then + aws_efs_workspace_check /workspace +fi # ── Corporate CA certificates ─────────────────────────────────────────────── # The host's CA material is bind-mounted read-only at /tmp/.host-ca. Triple-C @@ -641,6 +664,13 @@ chown claude:claude /home/claude/.gitconfig 2>/dev/null || true # folder is its state), and `done` appears when all are finished. The idle # watcher counts an unfinished clone as activity; triple-c-wip-push skips a # folder still `cloning`. +# With EFS storage /workspace outlives the task, so a repository already there +# is skipped on every later start. A clone is marked in progress in its own +# .git/config (`git clone -c triplec.cloning=1`, written before the fetch) and +# unmarked once it succeeds; a repository still marked was cut short (the task +# was killed mid-clone) and is removed and cloned again. A repository the user +# made never carries the mark. Every look at or removal of it runs as the user: +# the tree is theirs. # >>> aws_repos # clone_repos json root [status_dir] clone_repos() { @@ -650,6 +680,10 @@ clone_repos() { _clone_status() { [ -z "$status_dir" ] || printf '%s\t%s\n' "$1" "$2" >> "$status_dir/repos"; } while IFS= read -r -d '' folder && IFS= read -r -d '' url && IFS= read -r -d '' branch; do dest="$root/$folder" + if [ -e "$dest/.git" ] && [ "$(_triplec_as_user git config --file "$dest/.git/config" --get triplec.cloning 2>/dev/null)" = 1 ]; then + echo "entrypoint: the last clone of $folder was cut short; cloning it again" + _triplec_as_user rm -rf -- "$dest" + fi if [ -e "$dest/.git" ]; then echo "entrypoint: /workspace/$folder is already a repository; not cloning" _clone_status "$folder" exists @@ -657,7 +691,7 @@ clone_repos() { fi existed=0 [ -e "$dest" ] && existed=1 - local args=(clone --quiet) + local args=(clone --quiet -c triplec.cloning=1) [ -n "$branch" ] && args+=(--branch "$branch") args+=(-- "$url" "$dest") echo "entrypoint: cloning $folder..." @@ -671,6 +705,8 @@ clone_repos() { exec timeout -k 10 "$limit" git "$@"' _ "$limit" "${args[@]}" 2>&1