Files
windmill/backend/windmill-trigger/src/trigger_helpers.rs
T
hugocasaandClaude Opus 5.5 73f29ba7fb refuse html and redirect job responses on free cloud workspaces (#12402)
* fix: refuse html and redirect job responses on free cloud workspaces

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

* fix: refuse download, auth and cookie headers and look up the plan lazily

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

* fix: refuse comma-listed content types and parse each result once

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

* fix: allow calendar and ndjson responses on free cloud workspaces

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

* test: cover cookie headers and document the response flag

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

* fix: name the refused key and a fix in the error and allow plain content-type headers

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F4rzFrLWnqctKkG7Q8naXN

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 19:29:34 +01:00

1065 lines
32 KiB
Rust

use anyhow::Context;
use axum::response::IntoResponse;
use http::StatusCode;
use serde::Deserialize;
use serde_json::value::RawValue;
use sqlx::types::Json;
use std::collections::HashMap;
use std::future::Future;
use uuid::Uuid;
use windmill_common::{
db::{UserDB, UserDbWithAuthed, DB},
error::Result,
flows::{FlowModuleValue, Retry},
get_latest_deployed_hash_for_path, get_latest_flow_version_info_for_path,
jobs::{
get_has_preprocessor_from_content_and_lang, script_path_to_payload, ChosenBy, JobPayload,
},
runnable_ref::RunnableRef,
scripts::{get_full_hub_script_by_id, ScriptHash, ScriptLang},
triggers::{
HubOrWorkspaceId, RunnableFormat, RunnableFormatVersion, TriggerKind, TriggerMetadata,
RUNNABLE_FORMAT_VERSION_CACHE,
},
users::username_to_permissioned_as,
utils::HTTP_CLIENT,
worker::to_raw_value,
};
use windmill_queue::{push, PushArgs, PushArgsOwned, PushIsolationLevel};
use windmill_api_auth::{check_scopes, ApiAuthed};
#[cfg(feature = "enterprise")]
use windmill_api_jobs::execution::check_license_key_valid;
use windmill_api_jobs::{
execution::{
check_tag_available_for_workspace, delete_job_metadata_after_use,
push_flow_job_by_path_into_queue, push_script_job_by_path_into_queue,
result_to_http_response, run_wait_result_internal, schedule_job_deletion,
},
types::RunJobQuery,
};
struct ScriptInfo {
has_preprocessor: Option<bool>,
language: ScriptLang,
content: String,
schema: Option<sqlx::types::Json<PartialSchema>>,
}
#[derive(Debug, Deserialize)]
struct PropertyDefinition {
r#type: Option<Box<RawValue>>,
}
#[derive(Debug, Deserialize)]
struct PartialSchema {
properties: Option<HashMap<String, PropertyDefinition>>,
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum RunnableId {
FlowId(FlowId),
ScriptId(ScriptId),
HubScript(RunnableRef),
}
impl RunnableId {
pub fn from_script_hash(hash: ScriptHash) -> Self {
Self::ScriptId(ScriptId::ScriptHash(hash))
}
pub fn from_ref(runnable: &RunnableRef) -> Self {
let runnable = runnable.clone();
if runnable.is_flow() {
Self::FlowId(FlowId::FlowPath(runnable))
} else if runnable.hub_id().is_some() {
Self::HubScript(runnable)
} else {
Self::ScriptId(ScriptId::ScriptPath(runnable))
}
}
pub fn from_flow_version(version: i64) -> Self {
Self::FlowId(FlowId::FlowVersion(version))
}
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum FlowId {
FlowPath(RunnableRef),
FlowVersion(i64),
}
impl FlowId {
async fn get_flow_version_id(self, workspace_id: &str, db: &DB) -> Result<i64> {
let version_id = match self {
FlowId::FlowPath(flow) => {
let info = get_latest_flow_version_info_for_path(
None,
db,
workspace_id,
flow.path(),
true,
)
.await?;
info.version
}
FlowId::FlowVersion(version) => version,
};
Ok(version_id)
}
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum ScriptId {
ScriptPath(RunnableRef),
ScriptHash(ScriptHash),
}
impl ScriptId {
async fn get_script_hash(self, workspace_id: &str, db: &DB) -> Result<i64> {
let hash = match self {
ScriptId::ScriptPath(script) => {
let info = get_latest_deployed_hash_for_path(
None,
db.clone(),
workspace_id,
script.path(),
)
.await?;
info.hash
}
ScriptId::ScriptHash(hash) => hash.0,
};
Ok(hash)
}
}
async fn get_script_info(
db: &DB,
workspace_id: &str,
hash: i64,
) -> std::result::Result<ScriptInfo, sqlx::Error> {
sqlx::query_as!(ScriptInfo, "SELECT has_preprocessor, language as \"language: _\", content, schema as \"schema: _\" FROM script WHERE workspace_id = $1 AND hash = $2", workspace_id, hash)
.fetch_one(db)
.await
}
fn runnable_format_from_schema_without_preprocessor(
trigger_kind: &TriggerKind,
schema: Option<sqlx::types::Json<PartialSchema>>,
) -> RunnableFormat {
match trigger_kind {
TriggerKind::Mqtt | TriggerKind::Amqp
if schema.as_ref().is_some_and(|schema| {
schema.properties.as_ref().is_some_and(|properties| {
properties.iter().any(|(key, def)| {
key == "payload"
&& def.r#type.as_ref().is_some_and(|t| {
let typ = t.get().trim();
typ == "array" || (typ.starts_with('[') && typ.ends_with(']'))
})
})
})
}) =>
{
RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: false }
}
TriggerKind::Kafka | TriggerKind::Nats
if schema.as_ref().is_some_and(|schema| {
schema
.properties
.as_ref()
.is_some_and(|properties| properties.keys().any(|key| key == "msg"))
}) =>
{
RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: false }
}
_ => RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: false },
}
}
fn runnable_format_from_preprocessor_args(
args: Option<Vec<windmill_parser::Arg>>,
) -> RunnableFormat {
if let Some(args) = args {
if args.iter().any(|arg| arg.name == "wm_trigger")
|| (args.len() > 0 && args.iter().all(|arg| arg.name != "event"))
{
RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor: true }
} else {
RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: true }
}
} else {
RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor: true }
}
}
enum PreprocessorInfo {
Preprocessor { content: String, language: ScriptLang },
NoPreprocessor { schema: Option<sqlx::types::Json<PartialSchema>> },
}
#[derive(Debug, Deserialize)]
struct FlowInfo {
preprocessor_module: Option<sqlx::types::Json<FlowModuleValue>>,
schema: Option<sqlx::types::Json<PartialSchema>>,
}
fn get_preprocessor_args_from_content_and_language(
content: &str,
language: &ScriptLang,
) -> Result<Option<Vec<windmill_parser::Arg>>> {
let args = match language {
ScriptLang::Bun | ScriptLang::Bunnative | ScriptLang::Deno | ScriptLang::Nativets => {
let args = windmill_parser_ts::parse_deno_signature(
&content,
true,
false,
Some("preprocessor".to_string()),
)?;
Some(args.args)
}
#[cfg(feature = "python")]
ScriptLang::Python3 => {
let args = windmill_parser_py::parse_python_signature(
&content,
Some("preprocessor".to_string()),
false,
)?;
Some(args.args)
}
_ => None,
};
Ok(args)
}
pub async fn get_runnable_format(
runnable_id: RunnableId,
workspace_id: &str,
db: &DB,
trigger_kind: &TriggerKind,
) -> Result<RunnableFormat> {
let (key, preprocessor_info) = match runnable_id {
RunnableId::HubScript(script) => {
let version = script.hub_id().ok_or_else(|| {
windmill_common::error::Error::internal_err("Hub script without a Hub id")
})?;
let key = (HubOrWorkspaceId::Hub, version as i64, trigger_kind.clone());
let runnable_format = RUNNABLE_FORMAT_VERSION_CACHE.get(&key);
if let Some(runnable_format) = runnable_format {
tracing::debug!("Using cached runnable format for hub script {version}");
return Ok(runnable_format);
}
let hub_script = get_full_hub_script_by_id(version, &HTTP_CLIENT, Some(db)).await?;
let has_preprocessor = get_has_preprocessor_from_content_and_lang(
&hub_script.content,
&hub_script.language,
)?;
let partial_schema = serde_json::from_str(hub_script.schema.get())?;
(
key,
if has_preprocessor {
PreprocessorInfo::Preprocessor {
content: hub_script.content,
language: hub_script.language,
}
} else {
PreprocessorInfo::NoPreprocessor {
schema: Some(sqlx::types::Json(partial_schema)),
}
},
)
}
RunnableId::FlowId(flow_id) => {
let version = flow_id.get_flow_version_id(workspace_id, db).await?;
let key = (
HubOrWorkspaceId::WorkspaceId(workspace_id.to_string()),
version,
trigger_kind.clone(),
);
let runnable_format = RUNNABLE_FORMAT_VERSION_CACHE.get(&key);
if let Some(runnable_format) = runnable_format {
tracing::debug!("Using cached runnable format for flow version {version}");
return Ok(runnable_format);
}
let flow_info = sqlx::query_as!(
FlowInfo,
"SELECT
value->'preprocessor_module'->'value' as \"preprocessor_module: _\",
schema as \"schema: _\"
FROM flow_version
WHERE
id = $1
AND workspace_id = $2",
version,
workspace_id,
)
.fetch_one(db)
.await?;
if let Some(preprocessor_module) = flow_info.preprocessor_module {
match preprocessor_module.0 {
FlowModuleValue::RawScript { content, language, .. } => {
(key, PreprocessorInfo::Preprocessor { content, language })
}
FlowModuleValue::Script { path, hash, .. } => {
let hash = if let Some(hash) = hash {
hash.0
} else {
let script_hash = get_latest_deployed_hash_for_path(
None,
db.clone(),
workspace_id,
RunnableRef::from_path(&path, false)?.path(),
)
.await?;
script_hash.hash
};
let script_info = get_script_info(db, workspace_id, hash).await?;
(
key,
PreprocessorInfo::Preprocessor {
content: script_info.content,
language: script_info.language,
},
)
}
_ => {
return Err(windmill_common::error::Error::internal_err(
"Unsupported preprocessor module".to_string(),
));
}
}
} else {
(
key,
PreprocessorInfo::NoPreprocessor { schema: flow_info.schema },
)
}
}
RunnableId::ScriptId(script_id) => {
let hash = script_id.get_script_hash(workspace_id, db).await?;
let key = (
HubOrWorkspaceId::WorkspaceId(workspace_id.to_string()),
hash,
trigger_kind.clone(),
);
let runnable_format = RUNNABLE_FORMAT_VERSION_CACHE.get(&key);
if let Some(runnable_format) = runnable_format {
tracing::debug!("Using cached runnable format for script {hash}");
return Ok(runnable_format);
}
let script_info = get_script_info(db, workspace_id, hash).await?;
if script_info.has_preprocessor.unwrap_or(false) {
(
key,
PreprocessorInfo::Preprocessor {
content: script_info.content,
language: script_info.language,
},
)
} else {
(
key,
PreprocessorInfo::NoPreprocessor { schema: script_info.schema },
)
}
}
};
let runnable_format = match preprocessor_info {
PreprocessorInfo::Preprocessor { content, language } => {
let args = get_preprocessor_args_from_content_and_language(&content, &language)?;
runnable_format_from_preprocessor_args(args)
}
PreprocessorInfo::NoPreprocessor { schema } => {
runnable_format_from_schema_without_preprocessor(trigger_kind, schema)
}
};
RUNNABLE_FORMAT_VERSION_CACHE.insert(key, runnable_format);
Ok(runnable_format)
}
#[allow(dead_code)]
pub trait TriggerJobArgs {
type Payload: Send + Sync;
const TRIGGER_KIND: TriggerKind;
fn v1_payload_fn(payload: &Self::Payload) -> HashMap<String, Box<RawValue>>;
fn v2_payload_fn(payload: &Self::Payload) -> HashMap<String, Box<RawValue>> {
Self::v1_payload_fn(payload)
}
fn build_job_args_v2(
has_preprocessor: bool,
payload: &Self::Payload,
info: HashMap<String, Box<RawValue>>,
) -> PushArgsOwned {
let mut args = Self::v2_payload_fn(payload);
if has_preprocessor {
args.insert(
"kind".to_string(),
to_raw_value(&Self::TRIGGER_KIND.to_key()),
);
args.extend(info);
let args = HashMap::from([("event".to_string(), to_raw_value(&args))]);
PushArgsOwned { args, extra: None }
} else {
PushArgsOwned { args, extra: None }
}
}
fn build_job_args_v1(
has_preprocessor: bool,
payload: &Self::Payload,
info: HashMap<String, Box<RawValue>>,
) -> PushArgsOwned {
let trigger_key = Self::TRIGGER_KIND.to_key();
let args = Self::v1_payload_fn(payload);
let extra = if has_preprocessor {
Some(HashMap::from([(
"wm_trigger".to_string(),
to_raw_value(&serde_json::json!({
"kind": trigger_key,
trigger_key: info
})),
)]))
} else {
None
};
PushArgsOwned { args, extra }
}
fn build_job_args(
runnable: &RunnableRef,
w_id: &str,
db: &DB,
payload: Self::Payload,
info: HashMap<String, Box<RawValue>>,
) -> impl Future<Output = Result<PushArgsOwned>> + Send {
async move {
Self::build_job_args_from_runnable_id(
RunnableId::from_ref(runnable),
w_id,
db,
payload,
info,
)
.await
}
}
fn build_job_args_from_runnable_id(
runnable_id: RunnableId,
w_id: &str,
db: &DB,
payload: Self::Payload,
trigger_info: HashMap<String, Box<RawValue>>,
) -> impl Future<Output = Result<PushArgsOwned>> + Send {
async move {
tracing::debug!("Building job args for {runnable_id:?}");
let runnable_format =
get_runnable_format(runnable_id, w_id, db, &Self::TRIGGER_KIND).await?;
let job_args = match runnable_format {
RunnableFormat { version: RunnableFormatVersion::V1, has_preprocessor } => {
Self::build_job_args_v1(has_preprocessor, &payload, trigger_info)
}
RunnableFormat { version: RunnableFormatVersion::V2, has_preprocessor } => {
Self::build_job_args_v2(has_preprocessor, &payload, trigger_info)
}
};
Ok(job_args.omit_untrusted_interpolation())
}
}
fn build_capture_payloads(
payload: &Self::Payload,
info: HashMap<String, Box<RawValue>>,
) -> (PushArgsOwned, PushArgsOwned) {
let main_args = Self::build_job_args_v2(false, payload, info.clone());
let preprocessor_args = Self::build_job_args_v2(true, payload, info);
(main_args, preprocessor_args)
}
}
#[allow(dead_code)]
pub async fn trigger_runnable_inner<'c>(
db: &DB,
tx_o: Option<sqlx::Transaction<'c, sqlx::Postgres>>,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
mut args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
job_id: Option<Uuid>,
trigger: TriggerMetadata,
suspended_mode: Option<bool>,
) -> Result<(
Uuid,
Option<i32>,
Option<String>,
bool,
Option<sqlx::Transaction<'c, sqlx::Postgres>>,
)> {
// A trigger's args are built from a third party's payload — for an HTTP route without
// preprocessor the request body's keys *are* the job's top-level args — and the job runs
// as the trigger's owner, not as whoever sent that payload. So the sender may not steer
// how the runnable runs: pick the function called instead of `main` (and skip whatever
// `main` authenticates, e.g. the signature check of a `custom_script` route), plant
// module files in the job directory, or redirect where its workspace imports resolve.
// Every trigger kind funnels through here on its way to `push`, and none of them sets
// one of those keys itself, so this is the single place to do it rather than each args
// builder. It does not restrict what the runnable is *given*: ordinary inputs pass
// through untouched.
args.sanitize_untrusted();
let error_handler_args = error_handler_args.map(|args| {
let args = args
.0
.iter()
.map(|(key, value)| (key.to_owned(), to_raw_value(&value)))
.collect::<HashMap<String, Box<RawValue>>>();
Json(args)
});
let user_db = user_db.unwrap_or_else(|| UserDB::new(db.clone()));
let (uuid, resolved_delete_secs, early_return, has_failure_module, tx_out) = if runnable
.is_flow()
{
let run_query = RunJobQuery { job_id, suspended_mode, ..Default::default() };
let (uuid, early_return, has_failure_module, tx_out) = push_flow_job_by_path_into_queue(
authed,
db.clone(),
tx_o,
user_db,
workspace_id.to_string(),
runnable,
run_query,
args,
Some(trigger),
)
.await?;
(uuid, None, early_return, has_failure_module, tx_out)
} else {
let (uuid, resolved_delete_secs, tx_out) = trigger_script_internal(
db,
tx_o,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args.as_ref(),
trigger_path,
job_id,
trigger,
suspended_mode,
)
.await?;
(uuid, resolved_delete_secs, None, false, tx_out)
};
Ok((
uuid,
resolved_delete_secs,
early_return,
has_failure_module,
tx_out,
))
}
#[allow(dead_code)]
pub async fn trigger_runnable(
db: &DB,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
job_id: Option<Uuid>,
suspended_mode: bool,
trigger: TriggerMetadata,
) -> Result<axum::response::Response> {
let uuid = trigger_runnable_inner(
db,
None,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
job_id,
trigger,
Some(suspended_mode),
)
.await?
.0;
Ok((StatusCode::CREATED, uuid.to_string()).into_response())
}
#[allow(dead_code)]
pub async fn trigger_runnable_and_wait_for_result(
db: &DB,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
trigger: TriggerMetadata,
) -> Result<axum::response::Response> {
let username = authed.username.clone();
let (uuid, resolved_delete_secs, early_return, has_failure_module, _) = trigger_runnable_inner(
db,
None,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
None,
trigger,
None,
)
.await?;
let (result, success) = run_wait_result_internal(
db,
uuid,
&workspace_id,
early_return,
has_failure_module,
&username,
)
.await?;
match resolved_delete_secs {
Some(0) => delete_job_metadata_after_use(&db, uuid).await?,
Some(secs) => schedule_job_deletion(&db, uuid, &workspace_id, secs).await?,
None => {}
}
result_to_http_response(&db, &workspace_id, result, success).await
}
#[allow(dead_code)]
pub async fn trigger_runnable_and_wait_for_raw_result(
db: &DB,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
trigger: TriggerMetadata,
) -> Result<(Box<RawValue>, bool)> {
let (_, result, success) = trigger_runnable_and_wait_for_job(
db,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
trigger,
)
.await?;
Ok((result, success))
}
async fn trigger_runnable_and_wait_for_job(
db: &DB,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
trigger: TriggerMetadata,
) -> Result<(Uuid, Box<RawValue>, bool)> {
let username = authed.username.clone();
let (uuid, resolved_delete_secs, early_return, has_failure_module, _) = trigger_runnable_inner(
db,
None,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
None,
trigger,
None,
)
.await?;
let (result, success) = run_wait_result_internal(
db,
uuid,
&workspace_id,
early_return,
has_failure_module,
&username,
)
.await
.with_context(|| {
format!(
"Error fetching job result for {} {} (job {})",
if runnable.is_flow() { "flow" } else { "script" },
runnable.path(),
uuid
)
})?;
match resolved_delete_secs {
Some(0) => delete_job_metadata_after_use(&db, uuid).await?,
Some(secs) => schedule_job_deletion(&db, uuid, &workspace_id, secs).await?,
None => {}
}
Ok((uuid, result, success))
}
pub async fn trigger_runnable_and_wait_for_raw_result_with_error_ctx(
db: &DB,
user_db: Option<UserDB>,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
runnable: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, serde_json::Value>>>,
trigger_path: String,
trigger: TriggerMetadata,
) -> Result<Box<RawValue>> {
let (uuid, result, success) = trigger_runnable_and_wait_for_job(
db,
user_db,
authed,
chosen_by,
workspace_id,
runnable,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
trigger,
)
.await?;
if !success {
Err(windmill_common::error::Error::internal_err(format!(
"{} {} failed (job {uuid}): {}",
if runnable.is_flow() { "Flow" } else { "Script" },
runnable.path(),
result.get()
)))
} else {
Ok(result)
}
}
async fn trigger_script_internal<'c>(
db: &DB,
tx_o: Option<sqlx::Transaction<'c, sqlx::Postgres>>,
user_db: UserDB,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
script: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, Box<RawValue>>>>,
trigger_path: String,
job_id: Option<Uuid>,
trigger: TriggerMetadata,
suspended_mode: Option<bool>,
) -> Result<(
Uuid,
Option<i32>,
Option<sqlx::Transaction<'c, sqlx::Postgres>>,
)> {
if retry.is_none() && error_handler_path.is_none() {
let run_query = RunJobQuery { job_id, suspended_mode, ..Default::default() };
let (uuid, resolved_delete_secs, tx_out) = push_script_job_by_path_into_queue(
authed,
chosen_by,
db.clone(),
tx_o,
user_db,
workspace_id.to_string(),
script,
run_query,
args,
Some(trigger),
)
.await?;
Ok((uuid, resolved_delete_secs, tx_out))
} else {
let (uuid, resolved_delete_secs, tx_out) = trigger_script_with_retry_and_error_handler(
db,
tx_o,
user_db,
authed,
chosen_by,
workspace_id,
script,
args,
retry,
error_handler_path,
error_handler_args,
trigger_path,
job_id,
trigger,
suspended_mode,
)
.await?;
Ok((uuid, resolved_delete_secs, tx_out))
}
}
async fn trigger_script_with_retry_and_error_handler<'c>(
db: &DB,
tx_o: Option<sqlx::Transaction<'c, sqlx::Postgres>>,
user_db: UserDB,
authed: ApiAuthed,
chosen_by: ChosenBy,
workspace_id: &str,
script: &RunnableRef,
args: PushArgsOwned,
retry: Option<&sqlx::types::Json<Retry>>,
error_handler_path: Option<&str>,
error_handler_args: Option<&sqlx::types::Json<HashMap<String, Box<RawValue>>>>,
trigger_path: String,
job_id: Option<Uuid>,
trigger: TriggerMetadata,
suspended_mode: Option<bool>,
) -> Result<(
Uuid,
Option<i32>,
Option<sqlx::Transaction<'c, sqlx::Postgres>>,
)> {
#[cfg(feature = "enterprise")]
check_license_key_valid().await?;
check_scopes(&authed, || format!("jobs:run:scripts:{}", script.path()))?;
let retry = retry.map(|r| r.0.clone());
// A stored handler that does not parse fails when it fires; it must not stop the target.
let error_handler_path = error_handler_path.map(|p| {
RunnableRef::from_path(p, false).map_or_else(|_| p.to_string(), |r| r.path().to_string())
});
let error_handler_args = error_handler_args.map(|args| args.0.clone());
let (job_payload, tag, delete_after_use, delete_after_secs, timeout, on_behalf_of) = {
let db_authed = UserDbWithAuthed { db: user_db.clone(), authed: &authed.to_authed_ref() };
script_path_to_payload(
script,
chosen_by.origin(authed.to_authed_ref()),
Some(db_authed),
db.clone(),
&workspace_id,
Some(false),
)
.await?
};
let resolved_delete_secs = windmill_api_jobs::execution::resolve_delete_after_secs(
delete_after_use,
delete_after_secs,
);
let push_args = PushArgs { args: &args.args, extra: args.extra };
check_tag_available_for_workspace(&db, &workspace_id, &tag, &push_args, &authed).await?;
let return_tx = tx_o.is_some();
let (email, permissioned_as, push_authed, tx) = if let Some(tx) = tx_o {
(
authed.email.as_str(),
username_to_permissioned_as(&authed.username),
Some(authed.clone().into()),
PushIsolationLevel::Transaction(tx),
)
} else if let Some(on_behalf_of) = on_behalf_of.as_ref() {
(
on_behalf_of.email.as_str(),
on_behalf_of.permissioned_as.clone(),
None,
PushIsolationLevel::IsolatedRoot(db.clone()),
)
} else {
(
authed.email.as_str(),
username_to_permissioned_as(&authed.username),
Some(authed.clone().into()),
PushIsolationLevel::Isolated(user_db, authed.clone().into()),
)
};
let retryable_job_payload = match job_payload {
JobPayload::ScriptHash {
hash,
path,
concurrency_settings,
debouncing_settings,
cache_ttl,
cache_ignore_s3_path,
priority,
apply_preprocessor,
..
} => JobPayload::SingleStepFlow {
path,
hash: Some(hash),
flow_version: None,
// Keep the flow path until native retry covers handler semantics.
language: None,
args: HashMap::from(&push_args),
retry,
error_handler_path,
error_handler_args,
skip_handler: None,
cache_ttl,
cache_ignore_s3_path,
priority,
tag_override: tag.clone(),
apply_preprocessor,
trigger_path: Some(trigger_path.clone()),
concurrency_settings,
debouncing_settings,
},
JobPayload::ScriptHub { path, apply_preprocessor } => JobPayload::SingleStepFlow {
path,
hash: None,
flow_version: None,
language: None,
args: HashMap::from(&push_args),
retry,
error_handler_path,
error_handler_args,
skip_handler: None,
cache_ttl: None,
cache_ignore_s3_path: None,
priority: None,
tag_override: tag.clone(),
apply_preprocessor,
trigger_path: Some(trigger_path.clone()),
concurrency_settings: Default::default(),
debouncing_settings: Default::default(),
},
_ => {
return Err(windmill_common::error::Error::internal_err(format!(
"Unsupported job payload: {:?}",
job_payload
)))
}
};
let (uuid, tx) = push(
&db,
tx,
&workspace_id,
retryable_job_payload,
push_args,
authed.display_username(),
email,
permissioned_as,
authed.token_prefix.as_deref(),
authed.username_override.as_deref(),
None,
None,
None,
None,
None,
job_id,
false,
false,
None,
true,
tag,
timeout,
None,
None,
push_authed.as_ref(),
false,
None,
Some(trigger),
suspended_mode,
None,
)
.await?;
// If we were given a transaction, return it; otherwise commit it
if return_tx {
Ok((uuid, resolved_delete_secs, Some(tx)))
} else {
tx.commit().await?;
Ok((uuid, resolved_delete_secs, None))
}
}