@synopackageland/templates 0.9.5 → 0.9.7

package/templates/native-rust/backend/src/app/background/owner.rs

@@ -0,0 +1,77 @@
+//! Who a background request acts for: the authenticated DSM user and the UID
+//! looked up afresh for it.
+
+use std::sync::Arc;
+
+use serde::Deserialize;
+use serde_json::Value;
+use syno_pkg_land_sdk::BoxError;
+use syno_pkg_land_sdk::api::{self, Caller, Route};
+use syno_pkg_land_sdk::background::{Access, Submitter};
+use syno_pkg_land_sdk::ctx::Context;
+use syno_pkg_land_sdk::http::Request;
+
+use super::{BackgroundApi, Handler, background_error, identity_unavailable};
+use crate::app::routes::decode_params;
+
+impl BackgroundApi {
+    pub(super) fn access(&self, caller: &Caller) -> Access {
+        Access {
+            admin: caller.admin(),
+            owner: Submitter {
+                user: caller.user().to_string(),
+                uid: (self.uid_lookup)(caller.user()),
+            },
+        }
+    }
+
+    /// A route for any signed-in user whose UID resolves; administrators see
+    /// every owner's jobs and need no UID.
+    pub(super) fn owner(self: &Arc<Self>, method: &str, handler: Handler) -> Route {
+        let api = self.clone();
+        Route::handle_request(method, move |ctx, caller, req, params| {
+            let access = api.access(caller);
+            if !access.admin && !access.owner.valid() {
+                return Err(identity_unavailable().into());
+            }
+            handler(&api, ctx, caller, req, &access, params)
+        })
+    }
+
+    pub(super) fn admin(self: &Arc<Self>, method: &str, handler: Handler) -> Route {
+        let api = self.clone();
+        Route::handle_request(method, move |ctx, caller, req, params| {
+            if !caller.admin() {
+                return Err(api::Error::new(
+                    "unsupported",
+                    "background jobs need a DSM administrator",
+                )
+                .into());
+            }
+            handler(&api, ctx, caller, req, &api.access(caller), params)
+        })
+    }
+
+    pub(super) fn purge(
+        &self,
+        ctx: &Context,
+        caller: &Caller,
+        _: &Request,
+        _: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        #[derive(Default, Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct Params {
+            owner: Option<Submitter>,
+        }
+        let Some(owner) = decode_params::<Params>(params).ok().and_then(|p| p.owner) else {
+            return Err(api::Error::bad_request("exact owner is required").into());
+        };
+        let audit = self
+            .store
+            .purge_owner(ctx, &owner, caller.user())
+            .map_err(background_error)?;
+        Ok(serde_json::to_value(audit)?)
+    }
+}

package/templates/native-rust/backend/src/app/background/owner_tests.rs

@@ -0,0 +1,174 @@
+use serde_json::Value;
+use syno_pkg_land_sdk::background::{JobResult, Outcome, State};
+use syno_pkg_land_sdk::ctx::Context;
+
+use super::tests::{Env, data, id_params};
+use crate::app::test_support::{Stub, alice, bob, carol};
+
+fn ordinary_env() -> Env {
+    let env = Env::new();
+    env.set_uid(|name| match name {
+        "alice" => "1024".into(),
+        "bob" => "1025".into(),
+        "carol" => "1026".into(),
+        _ => String::new(),
+    });
+    env
+}
+
+fn owner_submit(env: &Env, auth: &Stub, key: &str) -> String {
+    let params = format!(r#"{{"key":"{key}","folder":"/share","relative":"a.txt"}}"#);
+    let (code, out) = env.call(auth, "bg.jobs.submit", &params);
+    assert_eq!(code, "", "submit {key}: {out}");
+    data(&out)["job"]["id"].as_str().unwrap().into()
+}
+
+fn job_count(env: &Env, auth: &Stub) -> usize {
+    let (_, out) = env.call(auth, "bg.jobs.list", "{}");
+    data(&out)["jobs"].as_array().unwrap().len()
+}
+
+#[test]
+fn owners_are_isolated_including_keys_and_counts() {
+    let env = ordinary_env();
+    let a = owner_submit(&env, &alice(), "same");
+    let b = owner_submit(&env, &bob(), "same");
+    let c = owner_submit(&env, &carol(), "same");
+    assert!(a != b && b != c, "idempotency key leaked across owners");
+    for auth in [bob(), carol()] {
+        assert_eq!(job_count(&env, &auth), 1);
+        let (_, out) = env.call(&auth, "bg.status", "{}");
+        assert_eq!(data(&out)["queued"], 1, "status leaks: {out}");
+        assert_eq!(data(&out)["admin"], false);
+    }
+    for method in [
+        "bg.jobs.get",
+        "bg.jobs.cancel",
+        "bg.jobs.pause",
+        "bg.jobs.resume",
+        "bg.jobs.result",
+    ] {
+        for id in [&a, &c, &"0".repeat(32)] {
+            let (code, out) = env.call(&bob(), method, &id_params(id));
+            assert_eq!(code, "not_found", "{method} {id}: {out}");
+        }
+    }
+    assert_eq!(job_count(&env, &alice()), 3, "admin must see all");
+    assert_eq!(env.call(&alice(), "bg.jobs.cancel", &id_params(&b)).0, "");
+}
+
+#[test]
+fn owner_result_and_uid_change_fail_closed() {
+    let env = ordinary_env();
+    let id = owner_submit(&env, &bob(), "one");
+    let ctx = Context::background();
+    env.store.claim(&ctx).unwrap();
+    env.store
+        .finish(
+            &ctx,
+            &id,
+            Outcome {
+                state: State::Succeeded,
+                result: Some(JobResult {
+                    sha256: "digest".into(),
+                    bytes: 5,
+                }),
+                ..Outcome::default()
+            },
+        )
+        .unwrap();
+    assert_eq!(env.call(&bob(), "bg.jobs.result", &id_params(&id)).0, "");
+    assert_eq!(
+        env.call(&carol(), "bg.jobs.result", &id_params(&id)).0,
+        "not_found"
+    );
+    env.set_uid(|_| "2000".into());
+    assert_eq!(
+        job_count(&env, &bob()),
+        0,
+        "same name with new UID saw old jobs"
+    );
+    assert_eq!(
+        env.call(&bob(), "bg.jobs.get", &id_params(&id)).0,
+        "not_found"
+    );
+    env.set_uid(|_| String::new());
+    assert_eq!(
+        env.call(&bob(), "bg.jobs.list", "{}").0,
+        "identity_unavailable"
+    );
+}
+
+#[test]
+fn personal_quota_and_admin_only_purge() {
+    let env = ordinary_env();
+    assert_eq!(env.call(&bob(), "bg.jobs.purge", "{}").0, "admin_required");
+    owner_submit(&env, &bob(), "one");
+    owner_submit(&env, &bob(), "two");
+    let params = r#"{"key":"three","folder":"/share","relative":"a.txt"}"#;
+    assert_eq!(
+        env.call(&bob(), "bg.jobs.submit", params).0,
+        "owner-queue-full"
+    );
+    owner_submit(&env, &carol(), "one");
+}
+
+#[test]
+fn purge_requires_an_admin_and_the_exact_owner() {
+    let env = ordinary_env();
+    let id = owner_submit(&env, &bob(), "one");
+    owner_submit(&env, &carol(), "one");
+    for params in [
+        "{}",
+        r#"{"owner":null}"#,
+        r#"{"owner":{"user":"bob","uid":"1025"},"x":1}"#,
+    ] {
+        assert_eq!(
+            env.call(&alice(), "bg.jobs.purge", params).0,
+            "bad_request",
+            "{params}"
+        );
+    }
+    let (code, out) = env.call(
+        &alice(),
+        "bg.jobs.purge",
+        r#"{"owner":{"user":"bob","uid":"1025"}}"#,
+    );
+    assert_eq!(code, "", "{out}");
+    assert_eq!(data(&out)["removed"], 1);
+    assert_eq!(
+        env.call(&alice(), "bg.jobs.get", &id_params(&id)).0,
+        "not_found"
+    );
+    assert_eq!(job_count(&env, &alice()), 1, "purge touched another owner");
+}
+
+#[test]
+fn fresh_ordinary_user_jobs_need_no_admin_setup() {
+    let env = Env::new();
+    env.set_uid(|name| if name == "bob" { "1025" } else { "1026" }.into());
+    let (code, out) = env.call(&bob(), "bg.status", "{}");
+    assert_eq!(code, "", "fresh status: {out}");
+    for key in ["enabled", "allowOrdinaryUsers"] {
+        assert!(
+            data(&out).get(key).is_none(),
+            "obsolete status switch {key}"
+        );
+    }
+    let id = owner_submit(&env, &bob(), "fresh");
+    for method in [
+        "bg.jobs.get",
+        "bg.jobs.cancel",
+        "bg.jobs.pause",
+        "bg.jobs.resume",
+    ] {
+        let (code, _) = env.call(&carol(), method, &id_params(&id));
+        assert_eq!(code, "not_found", "other owner {method}");
+    }
+    assert_eq!(env.call(&bob(), "bg.jobs.get", &id_params(&id)).0, "");
+    assert_eq!(env.call(&bob(), "bg.jobs.cancel", &id_params(&id)).0, "");
+    for method in ["bg.mode.set", "bg.users.set"] {
+        let (code, _): (String, Value) = env.call(&alice(), method, "{}");
+        assert_eq!(code, "unknown_method", "obsolete route {method}");
+    }
+}

package/templates/native-rust/backend/src/app/background/schedule.rs

@@ -0,0 +1,126 @@
+//! Recurring copies of an imported job: owners manage their own, an
+//! administrator re-approves them.
+
+use serde::Deserialize;
+use serde_json::{Value, json};
+use syno_pkg_land_sdk::api::{self, Caller};
+use syno_pkg_land_sdk::background::{Access, ScheduleRequest};
+use syno_pkg_land_sdk::ctx::Context;
+use syno_pkg_land_sdk::http::Request;
+use syno_pkg_land_sdk::{BoxError, jsonx};
+
+use super::{BackgroundApi, background_error, decode_id, identity_unavailable};
+use crate::app::routes::decode_params;
+
+impl BackgroundApi {
+    pub(super) fn schedules(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        decode_params::<jsonx::Empty>(params)?;
+        let list = self
+            .store
+            .schedules(ctx, access)
+            .map_err(background_error)?;
+        Ok(json!({"schedules": list}))
+    }
+
+    pub(super) fn create_schedule(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        #[derive(Default, Deserialize)]
+        #[serde(deny_unknown_fields, rename_all = "camelCase")]
+        struct Params {
+            #[serde(default)]
+            key: String,
+            #[serde(default)]
+            job_id: String,
+            #[serde(default)]
+            interval_seconds: i64,
+            #[serde(default)]
+            consent: bool,
+        }
+        let params: Params = decode_params(params)?;
+        if !access.owner.valid() {
+            return Err(identity_unavailable().into());
+        }
+        let request = ScheduleRequest {
+            key: params.key,
+            job_id: params.job_id,
+            interval_seconds: params.interval_seconds,
+            consent: params.consent,
+        };
+        let (schedule, duplicate) = self
+            .store
+            .create_schedule(ctx, &request, access)
+            .map_err(background_error)?;
+        Ok(json!({"schedule": schedule, "duplicate": duplicate}))
+    }
+
+    pub(super) fn disable_schedule(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        let id = decode_id(params)?;
+        let schedule = self
+            .store
+            .set_schedule(ctx, &id, false, access)
+            .map_err(background_error)?;
+        Ok(json!({"schedule": schedule}))
+    }
+
+    pub(super) fn enable_schedule(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        #[derive(Default, Deserialize)]
+        #[serde(deny_unknown_fields)]
+        struct Params {
+            #[serde(default)]
+            id: String,
+            #[serde(default)]
+            consent: bool,
+        }
+        let params = match decode_params::<Params>(params) {
+            Ok(p) if p.consent => p,
+            _ => return Err(api::Error::bad_request("explicit consent is required").into()),
+        };
+        let schedule = self
+            .store
+            .set_schedule(ctx, &params.id, true, access)
+            .map_err(background_error)?;
+        Ok(json!({"schedule": schedule}))
+    }
+
+    pub(super) fn delete_schedule(
+        &self,
+        ctx: &Context,
+        _: &Caller,
+        _: &Request,
+        access: &Access,
+        params: &[u8],
+    ) -> Result<Value, BoxError> {
+        let id = decode_id(params)?;
+        self.store
+            .delete_schedule(ctx, &id, access)
+            .map_err(background_error)?;
+        Ok(json!({"deleted": true}))
+    }
+}

package/templates/native-rust/backend/src/app/background/schedule_tests.rs

@@ -0,0 +1,108 @@
+use syno_pkg_land_sdk::background::{JobResult, Outcome, State};
+use syno_pkg_land_sdk::ctx::Context;
+
+use super::tests::{Env, data, id_params};
+use crate::app::test_support::{Stub, alice, bob, carol};
+
+fn ordinary_env() -> Env {
+    let env = Env::new();
+    env.set_uid(|name| match name {
+        "alice" => "1024".into(),
+        "bob" => "1025".into(),
+        "carol" => "1026".into(),
+        _ => String::new(),
+    });
+    env
+}
+
+fn submit_and_finish(env: &Env, auth: &Stub) -> String {
+    let (code, out) = env.call(
+        auth,
+        "bg.jobs.submit",
+        r#"{"key":"copy","folder":"/share","relative":"a.txt"}"#,
+    );
+    assert_eq!(code, "", "{out}");
+    let id: String = data(&out)["job"]["id"].as_str().unwrap().into();
+    let ctx = Context::background();
+    env.store.claim(&ctx).unwrap();
+    env.store
+        .finish(
+            &ctx,
+            &id,
+            Outcome {
+                state: State::Succeeded,
+                result: Some(JobResult {
+                    bytes: 5,
+                    ..JobResult::default()
+                }),
+                ..Outcome::default()
+            },
+        )
+        .unwrap();
+    id
+}
+
+fn schedule_count(env: &Env, auth: &Stub) -> usize {
+    let (_, out) = env.call(auth, "bg.schedules.list", "{}");
+    data(&out)["schedules"].as_array().unwrap().len()
+}
+
+#[test]
+fn schedule_routes_consent_owner_and_admin() {
+    let env = ordinary_env();
+    let id = submit_and_finish(&env, &bob());
+    let params = format!(r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600,"consent":true}}"#);
+    assert_eq!(
+        env.call(&carol(), "bg.schedules.create", &params).0,
+        "not_found"
+    );
+    for bad in [
+        format!(r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600}}"#),
+        format!(
+            r#"{{"key":"s","jobId":"{id}","intervalSeconds":3600,"consent":true,"owner":"carol"}}"#
+        ),
+    ] {
+        assert_eq!(
+            env.call(&bob(), "bg.schedules.create", &bad).0,
+            "bad_request",
+            "{bad}"
+        );
+    }
+    let (code, out) = env.call(&bob(), "bg.schedules.create", &params);
+    assert_eq!(code, "", "create: {out}");
+    let sid = data(&out)["schedule"]["id"].as_str().unwrap().to_string();
+    assert_eq!(schedule_count(&env, &carol()), 0, "list leak");
+    assert_eq!(schedule_count(&env, &alice()), 1, "admin list");
+    for method in ["bg.schedules.disable", "bg.schedules.delete"] {
+        assert_eq!(
+            env.call(&carol(), method, &id_params(&sid)).0,
+            "not_found",
+            "{method}"
+        );
+    }
+    let enable = format!(r#"{{"id":"{sid}","consent":true}}"#);
+    assert_eq!(
+        env.call(&bob(), "bg.schedules.enable", &enable).0,
+        "admin_required"
+    );
+    assert_eq!(
+        env.call(&alice(), "bg.schedules.disable", &id_params(&sid))
+            .0,
+        ""
+    );
+    assert_eq!(
+        env.call(&alice(), "bg.schedules.enable", &id_params(&sid))
+            .0,
+        "bad_request"
+    );
+    assert_eq!(env.call(&alice(), "bg.schedules.enable", &enable).0, "");
+    assert_eq!(
+        env.call(&bob(), "bg.schedules.delete", &id_params(&sid)).0,
+        ""
+    );
+    assert_eq!(
+        env.files.calls(),
+        1,
+        "no scheduling route calls File Station, uses a root grant or stores a session"
+    );
+}