Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 12 additions & 3 deletions api/crates/layerfs-api/tests/home_layout_3.rs
Original file line number Diff line number Diff line change
Expand Up @@ -87,11 +87,20 @@ fn home_with(tag: &str, extra: &[(&str, SdkValue)]) -> PathBuf {
let home = tempdir(tag);
home::open(&home).unwrap();
call(&home, "store.create", &[("name", t("shop"))]).unwrap();
write_record(
&paths::project_record(&home, "shop", "app"),
&SdkValue::map([("name", t("app")), ("created", SdkValue::Int(1))]),
// a real project, so the §4.2 home↔Store intersection lists and gets it
// across the conversion
let source = tempdir(&format!("{tag}-source"));
std::fs::write(source.join("README.md"), "app\n").unwrap();
call(
&home,
"project.init",
&[
("project", t("shop/app")),
("folder", t(&source.display().to_string())),
],
)
.unwrap();
let _ = std::fs::remove_dir_all(source);
write_record(
&paths::machine_record(&home, "dev"),
&SdkValue::map([
Expand Down
141 changes: 141 additions & 0 deletions api/crates/layerfs-api/tests/project_list_intersection.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,141 @@
//! project.list and project.get intersect the home's project entries with
//! the Store's filtered listing (spec §4.2): a home entry whose Store
//! project is retired (hidden) or absent is not listed, and project.get
//! answers it `NoSuchProject`; a live project still lists and gets.
use layerfs_api::home::{self, paths, write_record};
use layerfs_bridge::control::SdkValue;
use layerfs_bridge::sdk_values::{hex, unhex};
use layerfs_history::LayerStackId;
use layerfs_store::open_args::OpenArgs;
use layerfs_store::project::record::ProjectRecord;
use layerfs_store::record::StoreRecord;
use layerfs_store::service::with_service;
use layerfs_store_service::history::deletion::delete_stack;
use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};

static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);

fn tempdir(tag: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"layerfs-project-intersection-{tag}-{}-{}",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}

fn t(s: &str) -> SdkValue {
SdkValue::text(s)
}

fn call(home: &Path, name: &str, args: &[(&str, SdkValue)]) -> Result<SdkValue, (String, String)> {
let args = SdkValue::Map(
args.iter()
.map(|(n, v)| ((*n).to_owned(), v.clone()))
.collect(),
);
layerfs_api::call(Some(home), name, args, &mut |_| {}).map_err(|r| (r.code, r.message))
}

fn ok(home: &Path, name: &str, args: &[(&str, SdkValue)]) -> SdkValue {
call(home, name, args).unwrap_or_else(|e| panic!("{name}: {e:?}"))
}

/// Marks Store project `name` hidden, as the project.delete write path will
/// (T4.5b); the home entry stays, exactly the stale case §4.2 hides.
fn retire(home: &Path, store: &str, name: &str, stack: &str) {
let record = StoreRecord::read(home, store).unwrap().unwrap();
let open = OpenArgs {
home: Some(home.to_path_buf()),
store: Some(store.to_owned()),
project: Some(name.to_owned()),
store_path: Some(paths::store_file(home, store).display().to_string()),
store_record: Some(record.to_record().clone()),
postgresql: None,
};
let stack = LayerStackId::from_slice(&unhex(stack).unwrap()).unwrap();
with_service(&open, |service| {
delete_stack(&service.store, stack, 1234).unwrap();
Ok(SdkValue::Null)
})
.unwrap();
}

#[test]
fn a_retired_or_absent_store_project_is_not_listed_or_got() {
let home = tempdir("home");
std::fs::set_permissions(&home, std::fs::Permissions::from_mode(0o700)).unwrap();
home::open(&home).unwrap();
ok(&home, "store.create", &[("name", t("shop"))]);
let source = tempdir("folder");
std::fs::write(source.join("README.md"), "live\n").unwrap();
let init = |name: &str| {
ok(
&home,
"project.init",
&[
("project", t(&format!("shop/{name}"))),
("folder", t(&source.display().to_string())),
],
)
};
init("live");
init("retired");
let retired = ProjectRecord::read(&home, "shop", "retired")
.unwrap()
.expect("the retired entry");
let retired_stack = hex(&retired.stack().expect("the entry's manifest stack"));
retire(&home, "shop", "retired", &retired_stack);

// A home entry whose Store project is absent: a second home's stale
// record, or a failed home-entry removal. Its stack is not in the Store.
let absent = LayerStackId::from_authority([9; 16]).to_bytes();
write_record(
&paths::project_record(&home, "shop", "absent"),
&SdkValue::map([
("name", t("absent")),
("stack", t(&hex(&absent))),
("created", SdkValue::Int(1)),
]),
)
.unwrap();

// Only the live project lists; the retired and absent entries do not.
let list = ok(&home, "project.list", &[]);
let SdkValue::List(items) = list.get("items").unwrap() else {
panic!("{list:?}")
};
let names: Vec<&str> = items.iter().filter_map(|i| i.get_text("name")).collect();
assert_eq!(names, vec!["live"]);
// the named listing intersects the same way
let one = ok(&home, "project.list", &[("store", t("shop"))]);
let SdkValue::List(items) = one.get("items").unwrap() else {
panic!("{one:?}")
};
let names: Vec<&str> = items.iter().filter_map(|i| i.get_text("name")).collect();
assert_eq!(names, vec!["live"]);
// both stale home entries are still there; the Store, not the home, hides them
for name in ["retired", "absent"] {
assert!(paths::project_record(&home, "shop", name).exists(), "{name}");
}

// project.get refuses a hidden project even with its home entry present,
// and an entry the Store does not hold.
for name in ["retired", "absent"] {
let (code, message) = call(
&home,
"project.get",
&[("project", t(&format!("shop/{name}")))],
)
.unwrap_err();
assert_eq!(code, "NoSuchProject", "{name}: {message}");
}
let live = ok(&home, "project.get", &[("project", t("shop/live"))]);
assert_eq!(live.get_text("project"), Some("shop/live"));

std::fs::remove_dir_all(home).unwrap();
let _ = std::fs::remove_dir_all(source);
}
6 changes: 5 additions & 1 deletion api/crates/layerfs-cli/tests/concurrent_reads.rs
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,11 @@ fn parallel_branch_lists_never_trip_over_a_dropped_lease() {
vec!["project", "init", "s/p", source.to_str().unwrap()],
] {
let out = run(&mut layerfs(&home, &words));
assert!(out.status.success(), "layerfs {words:?}: {}", text(&out.stderr));
assert!(
out.status.success(),
"layerfs {words:?}: {}",
text(&out.stderr)
);
}
for round in 0..6 {
let children: Vec<_> = (0..8)
Expand Down
7 changes: 7 additions & 0 deletions control/crates/layerfs-control/src/project.rs
Original file line number Diff line number Diff line change
Expand Up @@ -11,3 +11,10 @@ use std::path::Path;
pub fn remove(home: &Path, events: &mut Events<'_>, project: &ProjectRef) -> Outcome {
layerfs_store::project::family::remove(home, events, project, crate::store::RELATED)
}

/// `project.delete(project)`: retires the project in its Store and removes
/// the caller home entry (spec §4). Add the API and MCP call-table entry in
/// T11; this is the service/control layer behind that dispatch.
pub fn delete(home: &Path, events: &mut Events<'_>, project: &ProjectRef) -> Outcome {
layerfs_store::project::delete::delete(home, events, project)
}
14 changes: 11 additions & 3 deletions control/crates/layerfs-control/src/worker_server.rs
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,8 @@
//! build sends nothing more and closes. Then a request `{ op, args }`, read with at most
//! [`REQUEST_WAIT`] between bytes. `worker.ping` answers who it is;
//! `store.call`, `store.file`, `store.reach`, `sandbox.host`, `project.stage`,
//! `project.init`, `project.export` and `project.remove` run one operation on
//! this machine,
//! `project.init`, `project.export`, `project.remove` and `project.delete` run
//! one operation on this machine,
//! with `home` set to the worker's own root (the machine's data disk),
//! never a path the caller sends. Answers are
//! `{ value }` or `{ refused }`, after any `{ event }` frames.
Expand All @@ -28,9 +28,10 @@ use layerfs_home::outcome::{refused, Outcome};
use layerfs_machine::worker::{
read_frame, read_frame_within, write_frame, Hello, HELLO_WAIT, MAX_HELLO,
};
use layerfs_store::project::delete::delete_project;
use layerfs_store::project::discovery::home_of;
use layerfs_store::project::export::in_worker as export_in_worker;
use layerfs_store::project::frame::{ExportFrame, InitFrame, RemoveFrame, StageFrame};
use layerfs_store::project::frame::{DeleteFrame, ExportFrame, InitFrame, RemoveFrame, StageFrame};
use layerfs_store::project::{init::in_worker, remove::remove_project, staged};
use std::net::{TcpListener, TcpStream};
use std::path::{Path, PathBuf};
Expand Down Expand Up @@ -274,6 +275,13 @@ fn run(
let root = home_of(Some(root))?;
remove_project(&root, &RemoveFrame::decode(&args)?)
}
// retires one project in the Store under this worker root and
// removes the worker own entry (2.0, T4.5b): `{ store, stack_id,
// deleted_ms?, project?, store_record? }`
"project.delete" => {
let root = home_of(Some(root))?;
delete_project(&root, &DeleteFrame::decode(&args)?)
}
// writes or discards one part of a caller's folder copy under this
// worker's root (#536 H11a)
"project.stage" => staged::run(root, &StageFrame::decode(args)?),
Expand Down
17 changes: 17 additions & 0 deletions control/crates/layerfs-control/tests/project_delete_call.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
//! `project.delete` is reachable at the control layer behind the call
//! dispatch T11 will add (the API/MCP call table itself is unchanged here).
use layerfs_home::events::Events;
use layerfs_home::names::ProjectRef;

#[test]
fn project_delete_is_reachable_from_control_and_refuses_an_unknown_store() {
let home = std::env::temp_dir().join(format!("layerfs-control-delete-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&home);
layerfs_home::home::layout::create(&home).unwrap();
let project = ProjectRef::parse("shop/app").unwrap();
let mut sink = |_| {};
let refused =
layerfs_control::project::delete(&home, &mut Events::new(&mut sink), &project).unwrap_err();
assert_eq!(refused.code, "NoSuchStore");
let _ = std::fs::remove_dir_all(&home);
}
Loading
Loading