|
|
|
|
@@ -95,6 +95,10 @@ pub async fn serve(addr: &str, state: AppState) -> anyhow::Result<()> {
|
|
|
|
|
// plugin will do with any of it. It puts `cmd` and `reqId` on the object and forwards it,
|
|
|
|
|
// exactly as it forwards a link code.
|
|
|
|
|
.route("/permissions/sync", post(perm_sync))
|
|
|
|
|
// Protocol 13 (D160): the whole store, owners included, in pages. The body is
|
|
|
|
|
// `{snapshotId?, page?}` and is forwarded as it is; paging is the plugin's and the
|
|
|
|
|
// website's business, never this process's, which keeps no copy of any page.
|
|
|
|
|
.route("/permissions/inventory", post(perm_inventory))
|
|
|
|
|
// Protocol 5 (R18): the plugin's own view of the game host's configuration tree. All
|
|
|
|
|
// three are correlated round trips and all three fail when the game is down, because
|
|
|
|
|
// "what is on that host's disk" has no stale answer worth giving — and, unlike a board,
|
|
|
|
|
@@ -102,9 +106,8 @@ pub async fn serve(addr: &str, state: AppState) -> anyhow::Result<()> {
|
|
|
|
|
// an operator edited over SSH and the website then overwrote.
|
|
|
|
|
.route("/config/files", get(config_files))
|
|
|
|
|
.route("/config/file", get(config_file))
|
|
|
|
|
// The only route on this sidecar that causes a WRITE on the game host, and the only one
|
|
|
|
|
// whose reply can take most of the RPC budget: the plugin holds it open across a reload
|
|
|
|
|
// and, at worst, across a rollback as well. See `CONFIG_RELOAD_WINDOW`.
|
|
|
|
|
// The only route on this sidecar that causes a WRITE on the game host. It answers once the
|
|
|
|
|
// files are on disk; the reload's outcome follows as a `config.outcome` event (protocol 13).
|
|
|
|
|
.route("/config/write", post(config_write))
|
|
|
|
|
// Protocol 8 (the module's PLAN.md §27): an event borrowing a value and giving it back.
|
|
|
|
|
// Three correlated round trips, and the sidecar knows nothing about any of them — not
|
|
|
|
|
@@ -120,6 +123,23 @@ pub async fn serve(addr: &str, state: AppState) -> anyhow::Result<()> {
|
|
|
|
|
.route("/world/zone", post(world_zone))
|
|
|
|
|
.route("/world/place", post(world_place))
|
|
|
|
|
.route("/world/revert", post(world_revert))
|
|
|
|
|
// Protocol 14 (§20.5): one of the game's own world events, now. Kept, never reverted.
|
|
|
|
|
.route("/world/call", post(world_call))
|
|
|
|
|
// Protocol 14 (§20.8): open one Dangerous Treasures event. The plugin remembers the key;
|
|
|
|
|
// DT picks the spot and despawns its own chest, so nothing here is kept either.
|
|
|
|
|
.route("/dt/start", post(dt_start))
|
|
|
|
|
// Protocol 14 (§20.9): place one guarded crate. The plugin remembers the key; the crate is
|
|
|
|
|
// kept when the run ends (Guarded Crate cannot end one alone), so nothing is kept here.
|
|
|
|
|
.route("/gc/place", post(gc_place))
|
|
|
|
|
// Protocol 14 (§20.11): console commands a step's author typed. The plugin keeps the key
|
|
|
|
|
// so nothing runs twice, fills the placeholders and decides who is online; this process
|
|
|
|
|
// moves the line and knows nothing of what any command does (no allowlist, D384).
|
|
|
|
|
.route("/commands/run", post(commands_run))
|
|
|
|
|
// Protocol 14 (§20.12): one RaidableBases base for a run, and a spot's checks. The plugin
|
|
|
|
|
// keeps the key and the run's base in its world registry, so `world.revert` takes it back
|
|
|
|
|
// like a zone; nothing is kept here.
|
|
|
|
|
.route("/raid/spawn", post(raid_spawn))
|
|
|
|
|
.route("/raid/check", post(raid_check))
|
|
|
|
|
// Protocol 10 (§29): who took part, what they may redeem, and a line in chat. The tally
|
|
|
|
|
// is counted and held by the plugin, the kit catalogue is Kits' own, and whether a chat
|
|
|
|
|
// line was already said is the plugin's memory. These move lines, like everything above.
|
|
|
|
|
@@ -127,6 +147,17 @@ pub async fn serve(addr: &str, state: AppState) -> anyhow::Result<()> {
|
|
|
|
|
.route("/tally/snapshot", get(tally_snapshot))
|
|
|
|
|
.route("/tally/close", post(tally_close))
|
|
|
|
|
.route("/kits", get(kits))
|
|
|
|
|
// Protocol 14 (the module's PLAN_REDESIGNS.md §2.6): how many of the given players have
|
|
|
|
|
// used a kit up or are on its cooldown, for the warning beside a kit weekend. The plugin
|
|
|
|
|
// reads Kits and answers counts; the list of players is the website's and is not kept.
|
|
|
|
|
.route("/kits/uses", post(kits_uses))
|
|
|
|
|
// Protocol 14, Economics (§20.3): thin forwards. The plugin remembers a payment's key so a
|
|
|
|
|
// retry never pays twice; nothing about a payment or a balance is kept here.
|
|
|
|
|
.route("/economics/pay", post(economics_pay))
|
|
|
|
|
.route("/economics/balances", post(economics_balances))
|
|
|
|
|
.route("/economics/adjust", post(economics_adjust))
|
|
|
|
|
// Protocol 14, Backpacks (§20.4): one player's backpack, read live and never kept here.
|
|
|
|
|
.route("/backpacks/read", post(backpacks_read))
|
|
|
|
|
.route("/chat", post(chat))
|
|
|
|
|
// Protocol 11 (§30): the map. The picture passes through in slices and is never kept
|
|
|
|
|
// here, and positions are asked for while somebody is looking and never filed (D111). The
|
|
|
|
|
@@ -139,6 +170,12 @@ pub async fn serve(addr: &str, state: AppState) -> anyhow::Result<()> {
|
|
|
|
|
// held by the plugin in memory and read by BetterChat on the chat path. Nothing here knows
|
|
|
|
|
// what a title is.
|
|
|
|
|
.route("/titles", post(titles))
|
|
|
|
|
// Protocol 13, RunicNPC (runicnpc PLAN.md stage 4): the site's NPC profiles and the
|
|
|
|
|
// server's placements. RunicNPC is called by the plugin, never by this process, and nothing
|
|
|
|
|
// here knows a profile from a placement. Four more thin forwards.
|
|
|
|
|
.route("/npc/profiles", get(npc_profiles).post(npc_profiles_set))
|
|
|
|
|
.route("/npc/placements", get(npc_placements))
|
|
|
|
|
.route("/npc/placement", post(npc_placement))
|
|
|
|
|
.route_layer(middleware::from_fn_with_state(state.clone(), gate));
|
|
|
|
|
|
|
|
|
|
let app = Router::new()
|
|
|
|
|
@@ -436,6 +473,13 @@ async fn perm_sync(State(st): State<AppState>, Json(body): Json<Value>) -> Respo
|
|
|
|
|
respond(st.rpc.call(&st.game, command, &req_id).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// One page of the plugin's permission inventory (protocol 13). Page 0 without a `snapshotId`
|
|
|
|
|
/// starts a fresh read; any other page names the snapshot page 0 answered with. A `perm.error`
|
|
|
|
|
/// (`busy`, `stale`, `too-large`) is an answer, and arrives as a `200` like the sync's.
|
|
|
|
|
async fn perm_inventory(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "perm.inventory", "an inventory request").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
|
|
|
struct ConfigPathQuery {
|
|
|
|
|
path: String,
|
|
|
|
|
@@ -527,6 +571,50 @@ async fn world_revert(State(st): State<AppState>, Json(body): Json<Value>) -> Re
|
|
|
|
|
forward_object(&st, body, "world.revert", "a revert").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Run one of the game's own world events for a run (protocol 14): a patrol helicopter, a cargo
|
|
|
|
|
/// ship, an airdrop and the rest. `world.called` (`called`, and `repeat` for a key already seen)
|
|
|
|
|
/// or `world.error` with a reason. What it starts is kept, so nothing is remembered here.
|
|
|
|
|
async fn world_call(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "world.call", "a world event call").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Open one Dangerous Treasures event for a run's step (protocol 14). `dt.opened` (where it
|
|
|
|
|
/// opened, and `repeat` for a key already seen) or `dt.error` with a reason, `dt-not-ready` among
|
|
|
|
|
/// them. DT despawns its own chest, so nothing is remembered here.
|
|
|
|
|
async fn dt_start(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "dt.start", "a Dangerous Treasures start").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Place one guarded crate for a run's step (protocol 14). `gc.placed` (where it landed, and
|
|
|
|
|
/// `repeat` for a key already seen) or `gc.error` with a reason, `npcspawn-missing` among them.
|
|
|
|
|
/// Guarded Crate ends its own event, so nothing is remembered here.
|
|
|
|
|
async fn gc_place(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "gc.place", "a guarded crate placement").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Run the console commands a step's author typed (protocol 14): once, or once per online
|
|
|
|
|
/// recipient. `command.ran` (how many ran, the console's replies, who was skipped as offline, and
|
|
|
|
|
/// `repeat` for a key already seen) or `command.error` with a reason, `unknown-command` among
|
|
|
|
|
/// them. A step's `teardown` rides its run and the plugin keeps it with the key; `teardownOf`
|
|
|
|
|
/// asks for the teardown kept under another key (D385). The plugin remembers the key, so nothing
|
|
|
|
|
/// is remembered here.
|
|
|
|
|
async fn commands_run(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "command.run", "a console command run").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Spawn one RaidableBases base for a run's step (protocol 14). `raid.queued` (its id, when the
|
|
|
|
|
/// raids helper made it the run's, and `repeat` for a key already seen) or `raid.error` with a
|
|
|
|
|
/// reason. The plugin's world registry holds the run's base; nothing is remembered here.
|
|
|
|
|
async fn raid_spawn(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "raid.spawn", "a raid base spawn").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Check a spot for a raid base without spawning one (protocol 14): `raid.checked`, with the
|
|
|
|
|
/// refusal's reason and the warnings, or `raid.error` when the spot cannot be checked at all.
|
|
|
|
|
async fn raid_check(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "raid.check", "a raid base spot check").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Start counting who takes part in a run. `tally.ok` or `tally.error` with a reason.
|
|
|
|
|
async fn tally_open(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "tally.open", "a tally").await
|
|
|
|
|
@@ -563,6 +651,38 @@ async fn kits(State(st): State<AppState>) -> Response {
|
|
|
|
|
respond(st.rpc.call(&st.game, command, &req_id).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// How many of a list of players have used one kit up, and how many are on its cooldown (protocol
|
|
|
|
|
/// 14). The body is `{kit, steamIds}` and is forwarded as it is; the answer is counts. A POST
|
|
|
|
|
/// because the list rides in the body — it can be as long as a server's linked players.
|
|
|
|
|
async fn kits_uses(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "kits.uses", "a kit-use question").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Coins to a list of players from an event step (protocol 14). The body is `{key, amount,
|
|
|
|
|
/// steamIds, message?, delivery?}`; the answer is `economics.paid` with each player's balance
|
|
|
|
|
/// before and after, or `economics.error` with a reason.
|
|
|
|
|
async fn economics_pay(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "economics.pay", "a payment").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The balances of a list of players, with the server's starting balance (protocol 14).
|
|
|
|
|
async fn economics_balances(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "economics.balances", "a balance question").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Staff deposit, withdraw or set one player's balance (protocol 14). The body is `{key, steamId,
|
|
|
|
|
/// op, amount}`; the answer is `economics.adjusted` with the balance before and after.
|
|
|
|
|
async fn economics_adjust(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "economics.adjust", "a balance adjustment").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// One player's backpack (protocol 14). The body is `{steamId}`; the answer is
|
|
|
|
|
/// `backpacks.contents` (`exists`, and with a backpack its `capacity`, `pageSize` and `items`), or
|
|
|
|
|
/// `backpacks.error` with a reason. The plugin only reads, and nothing is kept here.
|
|
|
|
|
async fn backpacks_read(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "backpacks.read", "a backpack read").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Say one line in the server's chat. A repeated key is answered `ok` by the plugin and not said
|
|
|
|
|
/// again, so a retried step never repeats itself.
|
|
|
|
|
async fn chat(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
@@ -575,6 +695,32 @@ async fn titles(State(st): State<AppState>, Json(body): Json<Value>) -> Response
|
|
|
|
|
forward_object(&st, body, "titles.set", "a title set").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The server's RunicNPC profiles as RunicNPC holds them: whether a site manages them, each profile,
|
|
|
|
|
/// and those refused. The website reads this before its first push, to adopt them (D244). Live.
|
|
|
|
|
async fn npc_profiles(State(st): State<AppState>) -> Response {
|
|
|
|
|
let req_id = st.rpc.next_req_id();
|
|
|
|
|
let command = json!({ "cmd": "npc.profiles", "reqId": req_id });
|
|
|
|
|
respond(st.rpc.call(&st.game, command, &req_id).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Replace the whole profile set (a push). `npc.ok` lists the profiles RunicNPC refused.
|
|
|
|
|
async fn npc_profiles_set(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "npc.profiles.set", "a profile push").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Every placement, the routes one may walk and the cost warning. Live: an admin's `/rnpc` in game
|
|
|
|
|
/// changes it at any moment.
|
|
|
|
|
async fn npc_placements(State(st): State<AppState>) -> Response {
|
|
|
|
|
let req_id = st.rpc.next_req_id();
|
|
|
|
|
let command = json!({ "cmd": "npc.placements", "reqId": req_id });
|
|
|
|
|
respond(st.rpc.call(&st.game, command, &req_id).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// One change to one placement, by `op`: add, set, remove, rename or respawn.
|
|
|
|
|
async fn npc_placement(State(st): State<AppState>, Json(body): Json<Value>) -> Response {
|
|
|
|
|
forward_object(&st, body, "npc.placement", "a placement change").await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// What this map is, where its picture comes from, and its monuments (protocol 11, stage one).
|
|
|
|
|
/// Live, and never cached here: a wipe changes the answer, and the module compares its key and
|
|
|
|
|
/// hash against what it holds to decide whether to fetch at all.
|
|
|
|
|
@@ -694,19 +840,14 @@ async fn config_file(State(st): State<AppState>, Query(q): Query<ConfigPathQuery
|
|
|
|
|
respond(st.rpc.call(&st.game, command, &req_id).await)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The window the plugin gives a reload to announce itself, mirrored here from
|
|
|
|
|
/// `ConfigReloadWindowSeconds` in `overlay/oxide/plugins/RunicGateway.cs`.
|
|
|
|
|
///
|
|
|
|
|
/// It is duplicated rather than negotiated because the two numbers are a *pairing*, like the
|
|
|
|
|
/// protocol version: the plugin owns the behaviour and this end owns the budget it has to fit in.
|
|
|
|
|
/// The test below is what keeps them honest — a worst-case write is two windows, and a
|
|
|
|
|
/// [`REPLY_TIMEOUT`](crate::rpc::REPLY_TIMEOUT) that does not cover both would abandon the caller
|
|
|
|
|
/// precisely when a rollback had just saved them, leaving the website to report a timeout over a
|
|
|
|
|
/// server that is perfectly healthy.
|
|
|
|
|
pub const CONFIG_RELOAD_WINDOW: Duration = Duration::from_secs(4);
|
|
|
|
|
|
|
|
|
|
/// Replace a set of configuration files and reload whatever owns them.
|
|
|
|
|
///
|
|
|
|
|
/// Since protocol 13 the reply does not wait for the reload. The plugin answers once the files are
|
|
|
|
|
/// on disk (`pending: true`, a `writeId`, and the `ceilingMs` it will wait), and reports the reload
|
|
|
|
|
/// as a `config.outcome` event when it settles. Protocol 12 held this RPC across the reload, which
|
|
|
|
|
/// forced the plugin's window under [`REPLY_TIMEOUT`](crate::rpc::REPLY_TIMEOUT) — and a cold
|
|
|
|
|
/// compile outlasted it and had a valid edit rolled back (the module's PLAN_FIXES.md F9).
|
|
|
|
|
///
|
|
|
|
|
/// Opaque body, exactly as `/permissions/sync`: `cmd` and `reqId` are written over whatever the
|
|
|
|
|
/// caller sent, and nothing else about the object is read here. What the website sends is whole
|
|
|
|
|
/// file *text* rather than a key and a value (D35), so there is nothing on this hop that could
|
|
|
|
|
@@ -750,16 +891,15 @@ async fn config_write(State(st): State<AppState>, Json(body): Json<Value>) -> Re
|
|
|
|
|
let result = st.rpc.call(&st.game, command, &req_id).await;
|
|
|
|
|
|
|
|
|
|
if matches!(result, Err(RpcError::Timeout)) {
|
|
|
|
|
// A bare `504` on a route that writes reads as "did my change land, and is the plugin
|
|
|
|
|
// still up?" — and unlike every other timeout on this sidecar, that question has a good
|
|
|
|
|
// answer. The plugin writes a whole set or restores a whole set, never half of either, so
|
|
|
|
|
// a re-read settles it; and a write that is still in flight is most likely inside the
|
|
|
|
|
// rollback this window pays for.
|
|
|
|
|
// A bare `504` on a route that writes reads as "did my change land?" — and unlike every
|
|
|
|
|
// other timeout on this sidecar, that question has a good answer. The plugin writes a
|
|
|
|
|
// whole set or none of it, and restores a whole set or none of it, so a re-read settles
|
|
|
|
|
// it. Since protocol 13 the reply no longer waits for a reload, so this is a slow host or
|
|
|
|
|
// a busy main thread, not a rollback in progress.
|
|
|
|
|
return (
|
|
|
|
|
StatusCode::GATEWAY_TIMEOUT,
|
|
|
|
|
Json(json!({
|
|
|
|
|
"error": "the plugin did not report within the write budget",
|
|
|
|
|
"reloadWindowSeconds": CONFIG_RELOAD_WINDOW.as_secs(),
|
|
|
|
|
"hint": "re-read the files: the plugin writes the whole set or restores it",
|
|
|
|
|
})),
|
|
|
|
|
)
|
|
|
|
|
@@ -1037,25 +1177,6 @@ mod tests {
|
|
|
|
|
assert_eq!(command["grants"], json!([]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// A command larger than the game link's own line cap is refused here, where the caller learns
|
|
|
|
|
/// why. Forwarded, it would be discarded by both ends without a word and present as a `504`.
|
|
|
|
|
/// The pairing in `CONFIG_RELOAD_WINDOW`'s own words, asserted rather than trusted.
|
|
|
|
|
///
|
|
|
|
|
/// The worst path through one configuration write is two windows — wait for the edited
|
|
|
|
|
/// plugin's reload, give up, restore the files, reload again — plus the write, the reads and
|
|
|
|
|
/// a line each way. If that does not fit inside the RPC timeout, the caller is abandoned at
|
|
|
|
|
/// exactly the moment the rollback saved it, and the website reports a timeout over a server
|
|
|
|
|
/// that is healthy and has the old config back.
|
|
|
|
|
#[test]
|
|
|
|
|
fn a_rollback_fits_inside_the_rpc_budget() {
|
|
|
|
|
let worst = CONFIG_RELOAD_WINDOW * 2;
|
|
|
|
|
assert!(
|
|
|
|
|
worst + Duration::from_secs(1) <= crate::rpc::REPLY_TIMEOUT,
|
|
|
|
|
"two reload windows ({worst:?}) plus a second of slack must fit in {:?}",
|
|
|
|
|
crate::rpc::REPLY_TIMEOUT
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 8's routes cannot choose their own command or correlation id either, and they keep
|
|
|
|
|
/// everything else the caller sent, unread.
|
|
|
|
|
#[test]
|
|
|
|
|
@@ -1107,6 +1228,220 @@ mod tests {
|
|
|
|
|
assert!(stamp(json!(["9"]), "tally.close", "r-4").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// RunicNPC's writes are stamped like every other forward: a placement change cannot become a
|
|
|
|
|
/// profile push, or anything else, by naming one.
|
|
|
|
|
#[test]
|
|
|
|
|
fn a_runicnpc_command_cannot_choose_its_own_command() {
|
|
|
|
|
let body = json!({ "cmd": "npc.profiles.set", "reqId": "theirs", "op": "remove", "id": "bandit-1" });
|
|
|
|
|
let stamped = stamp(body, "npc.placement", "r-9").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "npc.placement");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-9");
|
|
|
|
|
assert_eq!(stamped["op"], "remove");
|
|
|
|
|
assert_eq!(stamped["id"], "bandit-1");
|
|
|
|
|
|
|
|
|
|
let body = json!({ "cmd": "npc.placement", "profiles": { "warden": { "health": 250 } } });
|
|
|
|
|
let stamped = stamp(body, "npc.profiles.set", "r-10").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "npc.profiles.set");
|
|
|
|
|
assert_eq!(stamped["profiles"]["warden"]["health"], 250);
|
|
|
|
|
assert!(stamp(json!("warden"), "npc.profiles.set", "r-11").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 13: an inventory page request keeps its paging fields and cannot become a sync.
|
|
|
|
|
#[test]
|
|
|
|
|
fn an_inventory_request_cannot_choose_its_own_command() {
|
|
|
|
|
let body =
|
|
|
|
|
json!({ "cmd": "perm.sync", "reqId": "theirs", "snapshotId": "abc123", "page": 2 });
|
|
|
|
|
let stamped = stamp(body, "perm.inventory", "r-7").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "perm.inventory");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-7");
|
|
|
|
|
assert_eq!(stamped["snapshotId"], "abc123");
|
|
|
|
|
assert_eq!(stamped["page"], 2);
|
|
|
|
|
assert!(stamp(json!([0]), "perm.inventory", "r-8").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14: a kit-use question keeps its list and cannot become another command, and a
|
|
|
|
|
/// sync's `notices` pass through it untouched like every other part of the body.
|
|
|
|
|
#[test]
|
|
|
|
|
fn a_protocol_14_kit_use_question_and_notices_pass_through() {
|
|
|
|
|
let body = json!({ "cmd": "perm.sync", "kit": "vip", "steamIds": ["76561190000000001", "76561190000000002"] });
|
|
|
|
|
let stamped = stamp(body, "kits.uses", "r-12").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "kits.uses");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-12");
|
|
|
|
|
assert_eq!(stamped["kit"], "vip");
|
|
|
|
|
assert_eq!(stamped["steamIds"][1], "76561190000000002");
|
|
|
|
|
assert!(stamp(json!(["vip"]), "kits.uses", "r-13").is_none());
|
|
|
|
|
|
|
|
|
|
let body = json!({
|
|
|
|
|
"setId": "s-2",
|
|
|
|
|
"notices": [{ "key": "run:4:step:9", "steamId": "76561190000000001", "message": "You earned kit vip — type /kit vip", "delivery": "popup" }],
|
|
|
|
|
});
|
|
|
|
|
let stamped = stamp(body, "perm.sync", "r-14").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
stamped["notices"][0]["message"],
|
|
|
|
|
"You earned kit vip — type /kit vip"
|
|
|
|
|
);
|
|
|
|
|
assert_eq!(stamped["notices"][0]["delivery"], "popup");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, Economics: each body keeps its fields and is stamped with its own command, so
|
|
|
|
|
/// a payment cannot be sent as an adjustment by naming one in its body.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_economics_bodies_pass_through() {
|
|
|
|
|
let body = json!({ "cmd": "economics.adjust", "key": "7:4", "amount": 500.0, "steamIds": ["76561190000000001"], "message": "You earned {amount} coins", "delivery": "popup" });
|
|
|
|
|
let stamped = stamp(body, "economics.pay", "r-31").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "economics.pay");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-31");
|
|
|
|
|
assert_eq!(stamped["key"], "7:4");
|
|
|
|
|
assert_eq!(stamped["amount"], 500.0);
|
|
|
|
|
assert_eq!(stamped["message"], "You earned {amount} coins");
|
|
|
|
|
|
|
|
|
|
let stamped = stamp(
|
|
|
|
|
json!({ "steamIds": ["76561190000000001"] }),
|
|
|
|
|
"economics.balances",
|
|
|
|
|
"r-32",
|
|
|
|
|
)
|
|
|
|
|
.expect("an object is stamped");
|
|
|
|
|
assert_eq!(stamped["cmd"], "economics.balances");
|
|
|
|
|
assert_eq!(stamped["steamIds"][0], "76561190000000001");
|
|
|
|
|
|
|
|
|
|
let body = json!({ "key": "adj-1", "steamId": "76561190000000001", "op": "withdraw", "amount": 340.5 });
|
|
|
|
|
let stamped = stamp(body, "economics.adjust", "r-33").expect("an object is stamped");
|
|
|
|
|
assert_eq!(stamped["cmd"], "economics.adjust");
|
|
|
|
|
assert_eq!(stamped["op"], "withdraw");
|
|
|
|
|
assert_eq!(stamped["amount"], 340.5);
|
|
|
|
|
assert!(stamp(json!([1]), "economics.pay", "r-34").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, Backpacks: a read is stamped `backpacks.read` whatever its body names, so the
|
|
|
|
|
/// route can only ever read.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_backpacks_read_is_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "backpacks.write", "steamId": "76561198000000001" });
|
|
|
|
|
let stamped = stamp(body, "backpacks.read", "r-40").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "backpacks.read");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-40");
|
|
|
|
|
assert_eq!(stamped["steamId"], "76561198000000001");
|
|
|
|
|
assert!(stamp(json!("76561198000000001"), "backpacks.read", "r-41").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, world events: a call is stamped `world.call` whatever its body names, so the
|
|
|
|
|
/// route cannot place, revert or zone anything, and its params pass through untouched.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_world_call_is_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "world.revert", "reqId": "theirs", "runId": "9", "key": "9:2",
|
|
|
|
|
"event": "airdrop", "count": 3, "x": -412.0, "z": 1180.5 });
|
|
|
|
|
let stamped = stamp(body, "world.call", "r-50").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "world.call");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-50");
|
|
|
|
|
assert_eq!(stamped["event"], "airdrop");
|
|
|
|
|
assert_eq!(stamped["count"], 3);
|
|
|
|
|
assert_eq!(stamped["x"], -412.0);
|
|
|
|
|
assert!(stamp(json!("airdrop"), "world.call", "r-51").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, Dangerous Treasures: a start is stamped `dt.start` whatever its body names, so
|
|
|
|
|
/// the route can open a treasure event and nothing else, and its key and level pass through.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_dt_start_is_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "world.call", "reqId": "theirs", "key": "12:3", "level": 2 });
|
|
|
|
|
let stamped = stamp(body, "dt.start", "r-60").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "dt.start");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-60");
|
|
|
|
|
assert_eq!(stamped["key"], "12:3");
|
|
|
|
|
assert_eq!(stamped["level"], 2);
|
|
|
|
|
assert!(stamp(json!(2), "dt.start", "r-61").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, Guarded Crate: a placement is stamped `gc.place` whatever its body names, so
|
|
|
|
|
/// the route can place a guarded crate and nothing else, and its key, event and location pass
|
|
|
|
|
/// through.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_gc_place_is_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "dt.start", "reqId": "theirs", "key": "12:4", "event": "Elite", "monument": "powerplant_1", "offsetX": 10.0 });
|
|
|
|
|
let stamped = stamp(body, "gc.place", "r-62").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "gc.place");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-62");
|
|
|
|
|
assert_eq!(stamped["key"], "12:4");
|
|
|
|
|
assert_eq!(stamped["event"], "Elite");
|
|
|
|
|
assert_eq!(stamped["monument"], "powerplant_1");
|
|
|
|
|
assert_eq!(stamped["offsetX"], 10.0);
|
|
|
|
|
assert!(stamp(json!("Elite"), "gc.place", "r-63").is_none());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, console commands: a run is stamped `command.run` whatever its body names, so
|
|
|
|
|
/// the route runs commands and nothing else, and its key, commands and recipients pass through
|
|
|
|
|
/// byte for byte; the placeholders are the plugin's to fill.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_command_run_is_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "gc.place", "reqId": "theirs", "key": "12:5",
|
|
|
|
|
"commands": ["sr add {steamid} 100", "say \"{name} won\""],
|
|
|
|
|
"recipients": [{ "steamId": "76561198000000001", "name": "Some \"One\"" }] });
|
|
|
|
|
let stamped = stamp(body, "command.run", "r-64").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(stamped["cmd"], "command.run");
|
|
|
|
|
assert_eq!(stamped["reqId"], "r-64");
|
|
|
|
|
assert_eq!(stamped["key"], "12:5");
|
|
|
|
|
assert_eq!(stamped["commands"][0], "sr add {steamid} 100");
|
|
|
|
|
assert_eq!(stamped["commands"][1], "say \"{name} won\"");
|
|
|
|
|
assert_eq!(stamped["recipients"][0]["name"], "Some \"One\"");
|
|
|
|
|
assert!(stamp(json!(["rbe"]), "command.run", "r-65").is_none());
|
|
|
|
|
|
|
|
|
|
// D385: a step's teardown rides its run, and a teardown asked for by key alone names the
|
|
|
|
|
// run it is for; both are the plugin's to read.
|
|
|
|
|
let run = stamp(
|
|
|
|
|
json!({ "key": "12:6", "commands": ["rbe 1"], "teardown": ["rbe stop"] }),
|
|
|
|
|
"command.run",
|
|
|
|
|
"r-66",
|
|
|
|
|
)
|
|
|
|
|
.expect("an object is stamped");
|
|
|
|
|
assert_eq!(run["teardown"][0], "rbe stop");
|
|
|
|
|
let teardown = stamp(
|
|
|
|
|
json!({ "key": "12:6:teardown", "teardownOf": "12:6" }),
|
|
|
|
|
"command.run",
|
|
|
|
|
"r-67",
|
|
|
|
|
)
|
|
|
|
|
.expect("an object is stamped");
|
|
|
|
|
assert_eq!(teardown["cmd"], "command.run");
|
|
|
|
|
assert_eq!(teardown["teardownOf"], "12:6");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 14, RaidableBases: a spawn is stamped `raid.spawn` and a check `raid.check`
|
|
|
|
|
/// whatever their bodies name, so each route does its one thing; the plugin's own names for
|
|
|
|
|
/// difficulties, profiles and bases (D386), the spot and the settings pass through untouched.
|
|
|
|
|
#[test]
|
|
|
|
|
fn protocol_14_raid_spawn_and_check_are_stamped() {
|
|
|
|
|
let body = json!({ "cmd": "world.revert", "reqId": "theirs", "key": "12:7", "runId": "12",
|
|
|
|
|
"difficulty": "Wobbly", "profile": "Wobbly Bases", "base": "wobbly1",
|
|
|
|
|
"x": 650.0, "z": 2037.0, "heightAdjust": 5.0,
|
|
|
|
|
"pvp": false, "npcs": true, "npcCount": 0, "despawnMinutes": 90, "lock": true });
|
|
|
|
|
let spawn = stamp(body.clone(), "raid.spawn", "r-68").expect("an object is stamped");
|
|
|
|
|
|
|
|
|
|
assert_eq!(spawn["cmd"], "raid.spawn");
|
|
|
|
|
assert_eq!(spawn["reqId"], "r-68");
|
|
|
|
|
assert_eq!(spawn["key"], "12:7");
|
|
|
|
|
assert_eq!(spawn["difficulty"], "Wobbly");
|
|
|
|
|
assert_eq!(spawn["base"], "wobbly1");
|
|
|
|
|
assert_eq!(spawn["heightAdjust"], 5.0);
|
|
|
|
|
assert_eq!(spawn["npcCount"], 0);
|
|
|
|
|
assert_eq!(spawn["pvp"], false);
|
|
|
|
|
assert!(stamp(json!("Wobbly"), "raid.spawn", "r-69").is_none());
|
|
|
|
|
|
|
|
|
|
let check = stamp(body, "raid.check", "r-70").expect("an object is stamped");
|
|
|
|
|
assert_eq!(check["cmd"], "raid.check");
|
|
|
|
|
assert_eq!(check["x"], 650.0);
|
|
|
|
|
assert_eq!(check["profile"], "Wobbly Bases");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Protocol 12: a title set is forwarded whole. The markup inside each `text` is the module's
|
|
|
|
|
/// and the plugin's business, so it must arrive byte for byte as the website composed it.
|
|
|
|
|
#[test]
|
|
|
|
|
|
