From 67dcf145f4ba67ff88d8a7a8eba673e27b333e56 Mon Sep 17 00:00:00 2001 From: AlexRV12 <71396855+AlexRV12@users.noreply.github.com> Date: Tue, 3 Nov 2026 17:09:22 +0100 Subject: [PATCH] fix: parse a schedule's target once, at save and when it fires (#12183) --- ...7_normalize_schedule_target_paths.down.sql | 1 + ...907_normalize_schedule_target_paths.up.sql | 12 ++++++ backend/tests/schedule_target_path.rs | 43 +++++++++++++++++++ backend/windmill-api-schedule/src/lib.rs | 10 ++++- backend/windmill-queue/src/schedule.rs | 42 +++++++++--------- backend/windmill-queue/tests/schedule_push.rs | 20 +++++++++ cli/src/commands/schedule/schedule.ts | 12 +++++- ...schedule_push_permissioned_as_unit.test.ts | 24 +++++++++-- 8 files changed, 139 insertions(+), 25 deletions(-) create mode 100644 backend/migrations/20261102180907_normalize_schedule_target_paths.down.sql create mode 100644 backend/migrations/20261102180907_normalize_schedule_target_paths.up.sql create mode 100644 backend/tests/schedule_target_path.rs diff --git a/backend/migrations/20261102180907_normalize_schedule_target_paths.down.sql b/backend/migrations/20261102180907_normalize_schedule_target_paths.down.sql new file mode 100644 index 0000000000..8bc39341e4 --- /dev/null +++ b/backend/migrations/20261102180907_normalize_schedule_target_paths.down.sql @@ -0,0 +1 @@ +-- Nothing to do here: the stripped `/` named nothing. diff --git a/backend/migrations/20261102180907_normalize_schedule_target_paths.up.sql b/backend/migrations/20261102180907_normalize_schedule_target_paths.up.sql new file mode 100644 index 0000000000..11fe735698 --- /dev/null +++ b/backend/migrations/20261102180907_normalize_schedule_target_paths.up.sql @@ -0,0 +1,12 @@ +-- A schedule's target is compared with the path of the jobs it queues, and with a renamed +-- runnable's old path, neither of which starts with `/`. A target with more than one leading `/` +-- names nothing and is left as is: firing the schedule refuses it. +UPDATE schedule SET script_path = substr(script_path, 2) +WHERE script_path LIKE '/%' AND script_path NOT LIKE '//%'; +-- A restore puts the trashed row back as saved, so the copies awaiting one get the same fix. +UPDATE trashbin +SET item_data = jsonb_set(item_data, '{row,script_path}', + to_jsonb(substr(item_data #>> '{row,script_path}', 2))) +WHERE item_kind = 'schedule' + AND item_data #>> '{row,script_path}' LIKE '/%' + AND item_data #>> '{row,script_path}' NOT LIKE '//%'; diff --git a/backend/tests/schedule_target_path.rs b/backend/tests/schedule_target_path.rs new file mode 100644 index 0000000000..33762ac3af --- /dev/null +++ b/backend/tests/schedule_target_path.rs @@ -0,0 +1,43 @@ +use serde_json::json; +use sqlx::{Pool, Postgres}; + +use windmill_test_utils::*; + +#[sqlx::test(fixtures("base"))] +async fn create_stores_the_parsed_target(db: Pool) -> anyhow::Result<()> { + initialize_tracing().await; + let server = ApiServer::start(db.clone()).await?; + let base = format!( + "http://localhost:{}/api/w/test-workspace/schedules", + server.addr.port() + ); + let client = reqwest::Client::new(); + let create = |path: &str, script_path: &str| { + client + .post(format!("{base}/create")) + .bearer_auth("SECRET_TOKEN") + .json(&json!({ + "path": path, + "schedule": "0 0 0 * * *", + "timezone": "UTC", + "script_path": script_path, + "is_flow": false, + "args": {}, + "enabled": false, + })) + .send() + }; + + let resp = create("u/test-user/one_slash", "/u/test-user/x").await?; + assert_eq!(resp.status(), 200, "{}", resp.text().await?); + let stored: String = sqlx::query_scalar( + "SELECT script_path FROM schedule WHERE workspace_id = 'test-workspace' AND path = 'u/test-user/one_slash'", + ) + .fetch_one(&db) + .await?; + assert_eq!(stored, "u/test-user/x"); + + let resp = create("u/test-user/two_slashes", "//u/test-user/x").await?; + assert_eq!(resp.status(), 400, "{}", resp.text().await?); + Ok(()) +} diff --git a/backend/windmill-api-schedule/src/lib.rs b/backend/windmill-api-schedule/src/lib.rs index e2fa7da8fe..70b0984605 100644 --- a/backend/windmill-api-schedule/src/lib.rs +++ b/backend/windmill-api-schedule/src/lib.rs @@ -21,6 +21,7 @@ use windmill_api_auth::{ }; use windmill_audit::audit_oss::audit_log; use windmill_audit::ActionKind; +use windmill_common::runnable_ref::RunnableRef; use windmill_common::DB; use windmill_common::{ can_preserve_on_behalf_of, @@ -268,10 +269,17 @@ async fn create_schedule( Extension(db): Extension, Extension(user_db): Extension, Path(w_id): Path, - Json(ns): Json, + Json(mut ns): Json, ) -> Result { check_scopes(&authed, || format!("schedules:write:{}", ns.path))?; reject_reserved_schedule_path(&ns.path)?; + // Stored as parsed: the next-run check, the monitor's re-arm, the run history and renames + // all match the stored target exactly against job paths, which never start with `/`. + if !ns.script_path.is_empty() { + ns.script_path = RunnableRef::from_path(&ns.script_path, ns.is_flow)? + .path() + .to_string(); + } let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await; diff --git a/backend/windmill-queue/src/schedule.rs b/backend/windmill-queue/src/schedule.rs index e404e07f05..246a05bb0c 100644 --- a/backend/windmill-queue/src/schedule.rs +++ b/backend/windmill-queue/src/schedule.rs @@ -23,6 +23,7 @@ use windmill_common::get_latest_flow_version_id_for_path; use windmill_common::jobs::JobPayload; use windmill_common::jobs::JobTriggerKind; use windmill_common::jobs::OnBehalfOf; +use windmill_common::runnable_ref::RunnableRef; use windmill_common::runnable_settings::ConcurrencySettings; use windmill_common::runnable_settings::DebouncingSettings; use windmill_common::schedule::schedule_to_user; @@ -43,6 +44,7 @@ use windmill_common::{ async fn get_schedule_metadata<'c>( tx: &mut sqlx::Transaction<'c, sqlx::Postgres>, schedule: &Schedule, + target: &RunnableRef, ) -> Result<( Option, // tag Option, // timeout @@ -61,7 +63,7 @@ async fn get_schedule_metadata<'c>( None, &mut **tx, &schedule.workspace_id, - &schedule.script_path, + target.path(), false, ) .await?; @@ -70,7 +72,7 @@ async fn get_schedule_metadata<'c>( &mut **tx, version, &schedule.workspace_id, - &schedule.script_path, + target.path(), ) .await?; @@ -87,7 +89,7 @@ async fn get_schedule_metadata<'c>( Some(version), parsed_retry, )) - } else if schedule.script_path.starts_with("hub/") { + } else if target.path().starts_with("hub/") { Ok((None, None, None, None, None, parsed_retry)) } else { let ( @@ -111,7 +113,7 @@ async fn get_schedule_metadata<'c>( ) = windmill_common::get_latest_hash_for_path( &mut **tx, &schedule.workspace_id, - &schedule.script_path, + target.path(), false, ) .await?; @@ -138,6 +140,7 @@ pub async fn push_scheduled_job<'c>( )); } + let target = RunnableRef::from_path(&schedule.script_path, schedule.is_flow)?; let sched = ScheduleType::from_str(&schedule.schedule, schedule.cron_version.as_deref(), false)?; @@ -200,7 +203,7 @@ pub async fn push_scheduled_job<'c>( &schedule.workspace_id, &schedule.path, next, - &schedule.script_path + target.path() ) .fetch_one(&mut *tx) .warn_after_seconds_with_sql(1, "already_exists_job".to_string()) @@ -326,11 +329,11 @@ pub async fn push_scheduled_job<'c>( // Get metadata from the scheduled script/flow for tag, timeout, etc. let (tag, timeout, on_behalf_of, hash, flow_version, retry) = - get_schedule_metadata(&mut tx, schedule).await?; + get_schedule_metadata(&mut tx, schedule, &target).await?; ( JobPayload::SingleStepFlow { - path: schedule.script_path.clone(), + path: target.path().to_string(), hash, flow_version, language: None, @@ -366,7 +369,7 @@ pub async fn push_scheduled_job<'c>( None, &mut *tx, &schedule.workspace_id, - &schedule.script_path, + target.path(), false, ) .warn_after_seconds_with_sql(1, "get_latest_flow_version_id_for_path".to_string()) @@ -376,7 +379,7 @@ pub async fn push_scheduled_job<'c>( &mut *tx, version, &schedule.workspace_id, - &schedule.script_path, + target.path(), ) .warn_after_seconds_with_sql(1, "get_flow_version_info_from_version".to_string()) .await?; @@ -391,7 +394,7 @@ pub async fn push_scheduled_job<'c>( ( JobPayload::Flow { - path: schedule.script_path.clone(), + path: target.path().to_string(), dedicated_worker, apply_preprocessor: false, version, @@ -402,18 +405,18 @@ pub async fn push_scheduled_job<'c>( None, on_behalf_of, ) - } else if schedule.script_path.starts_with("hub/") { + } else if target.path().starts_with("hub/") { let tag = schedule.tag.clone().filter(|t| !t.is_empty()); let payload = match &schedule.retry { // The language is what lets `push` materialize this as a native retry // instead of a flow wrapper, which would queue the next tick at start. Some(retry) => JobPayload::SingleStepFlow { - path: schedule.script_path.clone(), + path: target.path().to_string(), hash: None, flow_version: None, language: Some( get_full_hub_script_by_path( - StripPath(schedule.script_path.clone()), + StripPath(target.path().to_string()), &HTTP_CLIENT, Some(db), ) @@ -438,10 +441,9 @@ pub async fn push_scheduled_job<'c>( concurrency_settings: ConcurrencySettings::default(), debouncing_settings: DebouncingSettings::default(), }, - None => JobPayload::ScriptHub { - path: schedule.script_path.clone(), - apply_preprocessor: false, - }, + None => { + JobPayload::ScriptHub { path: target.path().to_string(), apply_preprocessor: false } + } }; (payload, tag, None, None) } else { @@ -466,7 +468,7 @@ pub async fn push_scheduled_job<'c>( ) = windmill_common::get_latest_hash_for_path( &mut *tx, &schedule.workspace_id, - &schedule.script_path, + target.path(), false, ) .warn_after_seconds_with_sql(1, "get_latest_hash_for_path".to_string()) @@ -500,7 +502,7 @@ pub async fn push_scheduled_job<'c>( // cannot be evaluated and fails closed (no retry). ( JobPayload::SingleStepFlow { - path: schedule.script_path.clone(), + path: target.path().to_string(), hash: Some(hash), flow_version: None, language: Some(language), @@ -534,7 +536,7 @@ pub async fn push_scheduled_job<'c>( ( JobPayload::ScriptHash { hash, - path: schedule.script_path.clone(), + path: target.path().to_string(), cache_ttl, cache_ignore_s3_path, dedicated_worker, diff --git a/backend/windmill-queue/tests/schedule_push.rs b/backend/windmill-queue/tests/schedule_push.rs index 9e86386107..19fd7b88f6 100644 --- a/backend/windmill-queue/tests/schedule_push.rs +++ b/backend/windmill-queue/tests/schedule_push.rs @@ -145,6 +145,26 @@ mod schedule_push { Ok(()) } + #[sqlx::test(migrations = "../migrations", fixtures("base", "schedule_push"))] + async fn test_push_parses_target(db: Pool) -> anyhow::Result<()> { + let authed = make_authed(); + let schedule = make_schedule(|s| s.script_path = "/f/system/test_script".to_string()); + let tx = db.begin().await?; + push_scheduled_job(&db, tx, &schedule, Some(&authed), None) + .await? + .commit() + .await?; + let (_, path, _, _) = get_queued_job(&db).await.unwrap(); + assert_eq!(path.as_deref(), Some("f/system/test_script")); + + let schedule = make_schedule(|s| s.script_path = "//f/system/test_script".to_string()); + let tx = db.begin().await?; + assert!(push_scheduled_job(&db, tx, &schedule, Some(&authed), None) + .await + .is_err()); + Ok(()) + } + // ----------------------------------------------------------------------- // push_scheduled_job: flow schedule // ----------------------------------------------------------------------- diff --git a/cli/src/commands/schedule/schedule.ts b/cli/src/commands/schedule/schedule.ts index 096615c757..d2eb7ffc80 100644 --- a/cli/src/commands/schedule/schedule.ts +++ b/cli/src/commands/schedule/schedule.ts @@ -107,6 +107,13 @@ async function get(opts: GlobalOptions & { json?: boolean }, path: string) { } } +// A server stores a target without its one tolerated leading `/`, while one predating +// that stores it as typed. Compared as written, the two spellings never match and every +// push re-saves the schedule, which resets its run-as to a non-admin pusher. +function canonicalTarget(path: string): string { + return path?.startsWith("/") && !path.startsWith("//") ? path.slice(1) : path; +} + export async function pushSchedule( workspace: string, path: string, @@ -130,6 +137,8 @@ export async function pushSchedule( // Strip CLI-only boolean marker before sending to API delete (localSchedule as any).has_permissioned_as; + localSchedule.script_path = canonicalTarget(localSchedule.script_path); + // In a fork, the file's `enabled` is the parent's for a path the parent // also has (see sync push's `parentOwnedScheduleEnabled`): the fork's own // flag stays as it is. @@ -158,7 +167,8 @@ export async function pushSchedule( } if (schedule) { - if (isSuperset(localSchedule, schedule)) { + const remote = { ...schedule, script_path: canonicalTarget(schedule.script_path) }; + if (isSuperset(localSchedule, remote)) { log.debug(`Schedule ${path} is up to date`); return; } diff --git a/cli/test/schedule_push_permissioned_as_unit.test.ts b/cli/test/schedule_push_permissioned_as_unit.test.ts index 953f8a415e..43984503bd 100644 --- a/cli/test/schedule_push_permissioned_as_unit.test.ts +++ b/cli/test/schedule_push_permissioned_as_unit.test.ts @@ -13,12 +13,13 @@ import { mockServices } from "./mock_services.ts"; let updateScheduleCalls: any[] = []; let remotePermissionedAs: string | undefined = "u/svc"; +let remoteScriptPath = "u/admin/script"; const REMOTE_SCHEDULE = () => ({ path: "u/admin/sched", schedule: "0 0 */6 * * *", timezone: "Etc/UTC", - script_path: "u/admin/script", + script_path: remoteScriptPath, is_flow: false, args: {}, enabled: false, @@ -74,8 +75,8 @@ await mockModule("../src/core/auth.ts", (real) => ({ requireLogin: async () => ({}), })); -const scheduleCommand = (await import("../src/commands/schedule/schedule.ts")) - .default; +const scheduleModule = await import("../src/commands/schedule/schedule.ts"); +const scheduleCommand = scheduleModule.default; async function pushIn(wmillYamlTail: string): Promise { const dir = await mkdtemp(join(tmpdir(), "windmill_sched_push_")); @@ -107,6 +108,7 @@ describe("wmill schedule push ownership", () => { beforeEach(() => { updateScheduleCalls = []; remotePermissionedAs = "u/svc"; + remoteScriptPath = "u/admin/script"; }); test("keeps the remote's permissioned_as under syncBehavior v1", async () => { @@ -141,4 +143,20 @@ describe("wmill schedule push ownership", () => { expect(body.permissioned_as).toBeUndefined(); expect(body.preserve_permissioned_as).toBeUndefined(); }); + + for (const [server, stored] of [ + ["a current server", "u/admin/script"], + ["an older server", "/u/admin/script"], + ]) { + test(`a target written with one leading slash matches what ${server} stores (${stored})`, async () => { + remoteScriptPath = stored; + const { permissioned_as: _, path: __, ...remote } = REMOTE_SCHEDULE(); + await scheduleModule.pushSchedule("w", "u/admin/sched.schedule.yaml", undefined, { + ...remote, + script_path: "/u/admin/script", + } as any); + + expect(updateScheduleCalls).toHaveLength(0); + }); + } });