3b650a2b14
Add a server-side, atomic, declarative reconcile loop for a single app —
the foundation of the project-tool design. Developers describe an app's
scripts, routes, triggers, and secret-names in `picloud.toml`, then
`pic pull / plan / apply [--prune]` to converge live state to the manifest.
Server (manager-core):
- apply_service: a pure diff engine (compute_diff) shared by plan and
apply, plus an ApplyService that composes the existing per-repo writes
into ONE Postgres transaction. Identity keys mirror the DB UNIQUE
constraints (script=lower(name); route=(method,host_kind,host,
path_kind,path); trigger=per-kind semantic tuple; secret=name).
Apply takes a per-app advisory lock, recomputes the diff in-tx, applies
scripts -> routes -> triggers, prunes dependents-first, commits, then
refreshes the route table once post-commit.
- apply_api: POST /apps/{id}/plan (AppRead) and /apps/{id}/apply.
Apply requires the per-kind write caps the bundle exercises (all three
when --prune), plus AppSecretsRead when it binds an email trigger.
- tx-accepting repo siblings (insert/update/delete *_tx) so the existing
create/update/delete delegate to one SQL definition each.
- email triggers reference an inbound secret by NAME; the value is
resolved, decrypted (AAD-bound), and re-sealed server-side at apply —
it never travels in the manifest.
CLI (picloud-cli):
- manifest.rs (picloud.toml model), client plan/apply, and the pull/plan/
apply commands. pull rejects filesystem-unsafe script names up front.
Safety properties enforced and tested:
- idempotent: a freshly-pulled manifest re-applies as all-NoOp.
- atomic: a mid-bundle failure rolls back with nothing written.
- routes delete-before-insert so a freed binding is reusable in one apply.
- queue one-consumer invariant held inside the shared tx.
- email triggers are never pruned, and a script that still owns an
email/dead-letter trigger can't be pruned (the FK cascade would destroy
the sealed secret) — refused with a pointer to `pic triggers rm`.
- plan and apply agree on unset email-secret references.
No migration: the existing schema's UNIQUE constraints serve as identity
keys. Groups, env-scoping, and the `enabled` toggle are later milestones.
Tested: manager-core lib (360) + CLI bins (27) + 8 project-tool journeys
(pull/plan/apply/prune/email+queue), all green; clippy -D warnings clean.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
112 lines
3.3 KiB
Rust
112 lines
3.3 KiB
Rust
//! `pic apply --prune` journey: a resource dropped from the manifest
|
|
//! survives a plain (additive) apply but is deleted with `--prune`.
|
|
|
|
use std::fs;
|
|
|
|
use tempfile::TempDir;
|
|
|
|
use crate::common;
|
|
use crate::common::cleanup::AppGuard;
|
|
|
|
fn scripts_ls(env: &common::TestEnv, slug: &str) -> String {
|
|
String::from_utf8(
|
|
common::pic_as(env)
|
|
.args(["scripts", "ls", "--app", slug])
|
|
.output()
|
|
.unwrap()
|
|
.stdout,
|
|
)
|
|
.unwrap()
|
|
}
|
|
|
|
#[ignore = "needs DATABASE_URL pointing at a running Postgres"]
|
|
#[test]
|
|
fn prune_deletes_stale_resources() {
|
|
let Some(fx) = common::fixture_or_skip() else {
|
|
return;
|
|
};
|
|
let env = common::admin_env(fx);
|
|
let slug = common::unique_slug("prune");
|
|
common::pic_as(&env)
|
|
.args(["apps", "create", &slug])
|
|
.assert()
|
|
.success();
|
|
let _guard = AppGuard::new(&env.url, &env.token, &slug);
|
|
|
|
let dir = TempDir::new().unwrap();
|
|
fs::create_dir_all(dir.path().join("scripts")).unwrap();
|
|
fs::write(dir.path().join("scripts/keep.rhai"), "let x = 1; x").unwrap();
|
|
fs::write(dir.path().join("scripts/drop.rhai"), "let y = 2; y").unwrap();
|
|
let manifest_path = dir.path().join("picloud.toml");
|
|
|
|
// v1: two scripts + a route on `drop`.
|
|
let v1 = format!(
|
|
"[app]\nslug = \"{slug}\"\nname = \"Prune Test\"\n\n\
|
|
[[scripts]]\nname = \"keep\"\nfile = \"scripts/keep.rhai\"\n\n\
|
|
[[scripts]]\nname = \"drop\"\nfile = \"scripts/drop.rhai\"\n\n\
|
|
[[routes]]\nscript = \"drop\"\nmethod = \"GET\"\n\
|
|
host_kind = \"any\"\npath_kind = \"exact\"\npath = \"/drop\"\n"
|
|
);
|
|
fs::write(&manifest_path, &v1).unwrap();
|
|
common::pic_as(&env)
|
|
.args(["apply", "--file"])
|
|
.arg(&manifest_path)
|
|
.assert()
|
|
.success();
|
|
|
|
// v2: drop `drop` and its route.
|
|
let v2 = format!(
|
|
"[app]\nslug = \"{slug}\"\nname = \"Prune Test\"\n\n\
|
|
[[scripts]]\nname = \"keep\"\nfile = \"scripts/keep.rhai\"\n"
|
|
);
|
|
fs::write(&manifest_path, &v2).unwrap();
|
|
|
|
// Plain apply is additive — `drop` survives.
|
|
common::pic_as(&env)
|
|
.args(["apply", "--file"])
|
|
.arg(&manifest_path)
|
|
.assert()
|
|
.success();
|
|
assert!(
|
|
scripts_ls(&env, &slug).contains("drop"),
|
|
"additive apply must not delete"
|
|
);
|
|
|
|
// Prune apply removes `drop` and its route.
|
|
let out = common::pic_as(&env)
|
|
.args(["apply", "--file"])
|
|
.arg(&manifest_path)
|
|
.arg("--prune")
|
|
.output()
|
|
.expect("apply --prune");
|
|
assert!(
|
|
out.status.success(),
|
|
"prune failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
let report = String::from_utf8(out.stdout).unwrap();
|
|
assert!(
|
|
report.contains("-1"),
|
|
"expected deletions in report:\n{report}"
|
|
);
|
|
|
|
let s = scripts_ls(&env, &slug);
|
|
assert!(!s.contains("drop"), "prune should delete `drop`:\n{s}");
|
|
assert!(s.contains("keep"), "prune must keep `keep`:\n{s}");
|
|
|
|
// Plan is clean after prune.
|
|
let p = String::from_utf8(
|
|
common::pic_as(&env)
|
|
.args(["plan", "--file"])
|
|
.arg(&manifest_path)
|
|
.output()
|
|
.unwrap()
|
|
.stdout,
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
!p.contains("delete"),
|
|
"plan should be clean after prune:\n{p}"
|
|
);
|
|
}
|