From 11dd4118ce43136da900601401ee0d04e60c246b Mon Sep 17 00:00:00 2001 From: pyranota <92104930+pyranota@users.noreply.github.com> Date: Fri, 15 Aug 2025 15:03:32 +0200 Subject: [PATCH] feat: add ruby support (#5939) * implement single line pin * make panic-safe * use pin even if multiple modules imported withing single statement * add repins and make imports respect pins * keep all pins * Allow multiple pins * add comments + handle stuff more safely * fix fully qualified imports * remove ignore * sort nested * apply unique to output requirements list * fix typo * remove mut * update sqlx * sort imports * sort imports * fix formatter and format * feat: add ruby support * fix * update sqlx * add ruby to flake.nix Signed-off-by: pyranota * upgrade par_install_language_dependencies helper rename fields + allow passing custom payload Signed-off-by: pyranota * change migrations Signed-off-by: pyranota * make full pipeline work! Signed-off-by: pyranota * do a bit fixing * stage Signed-off-by: pyranota * add ruby in dockerfiles Signed-off-by: pyranota * implement auto-require + 'windmill/inline' Signed-off-by: pyranota * create 'windmill/inline' only if does not exist Signed-off-by: pyranota * add nsjail Signed-off-by: pyranota * update global settings Signed-off-by: pyranota * add ruby icon * generate lockfile on deploy (but broken) Signed-off-by: pyranota * fix(frontend): display deployed script lockfile and other info Signed-off-by: pyranota * feat: add mini-wmill client Methods: - get_resource - get_variable Additionally add shortcuts on frontend Signed-off-by: pyranota * add nit warning Signed-off-by: pyranota * support private repos credentials Signed-off-by: pyranota * fix compilation error Signed-off-by: pyranota * found rustc bug + refactor universal installer Signed-off-by: pyranota * more refactor + fixes Signed-off-by: pyranota * bug fixing + polishing Signed-off-by: pyranota * cleanup Signed-off-by: pyranota * change 'windmill/inline' Signed-off-by: pyranota * delegate env_clear to universal installer Signed-off-by: pyranota * update init script Signed-off-by: pyranota * add cli support Signed-off-by: pyranota * unhardcode frontend Signed-off-by: pyranota * fix cli Signed-off-by: pyranota * fix init script Signed-off-by: pyranota * make it work on ms windows Signed-off-by: pyranota * do not clean env in the end Signed-off-by: pyranota * fix windows (again) Signed-off-by: pyranota * include PROXY_ENVS (untested) Signed-off-by: pyranota * feat: self-signed certs + proxy support (tested) Signed-off-by: pyranota * flake: pin ruby to 3.4 * merge follow-ups Signed-off-by: pyranota * remove obsolete libc crate Signed-off-by: pyranota * cleanup parser Signed-off-by: pyranota * fix java ci Signed-off-by: pyranota * cleanup Signed-off-by: pyranota * fix nits Signed-off-by: pyranota * Update backend/windmill-worker/src/universal_pkg_installer.rs Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com> * Update backend/windmill-worker/src/ruby_executor.rs Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com> * add nsjail for lock stage Signed-off-by: pyranota * fix merge Signed-off-by: pyranota * Update common.rs * regen windmill-api-client Signed-off-by: pyranota * fix tests Signed-off-by: pyranota * fix tests again Signed-off-by: pyranota * reference published ruby parser Signed-off-by: pyranota --------- Signed-off-by: pyranota Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com> --- ...2bbc4718cbb8ad6e2f13eae6b14f129d12936.json | 3 +- ...b21270131e9e93ca10d195664e7e5a774fe9e.json | 3 +- ...634619565e4ef342051af23760c11edac5ee8.json | 3 +- ...73917ed13269f2ee20b86df79fca2c8efe672.json | 3 +- ...a6c391c4d0054a618b861464ee37239f1f1e0.json | 3 +- ...3715bdc6a52b76c89f3a3913023b13c4e085c.json | 15 + ...3b9b96854e5bfd752e45922c358c42ebea0c4.json | 3 +- ...94f91df7e588d4d2431bc85f4d8734920c8bf.json | 3 +- ...72889ff257db0f0e3e9252adda2e4ef2039d6.json | 3 +- ...8807bc464a81c0883e68f5a69b89b94b0b34b.json | 3 +- ...00b28f3256491fdaa168591adc7b4b9f3327a.json | 3 +- ...5ef756b8e5c1955fbe111df9ee171dc262338.json | 3 +- ...a72de0a9de0d58ef8c28dd709adf3be021597.json | 3 +- ...b64792c00da1d713d7ca8f9904ccce7bfdae7.json | 248 ++ ...77afbd8b3a660b3be27514b517c077c63c238.json | 3 +- backend/Cargo.lock | 26 + backend/Cargo.toml | 9 +- .../20250721160151_add_ruby.down.sql | 1 + .../migrations/20250721160151_add_ruby.up.sql | 3 + backend/parsers/windmill-parser-py/src/lib.rs | 2 +- .../parsers/windmill-parser-ruby/Cargo.toml | 19 + .../parsers/windmill-parser-ruby/src/lib.rs | 410 +++ .../windmill-parser-ruby/src/wasm_libc.rs | 297 ++ backend/parsers/windmill-parser-ts/src/lib.rs | 2 +- .../parsers/windmill-parser-wasm/Cargo.toml | 2 + backend/parsers/windmill-parser-wasm/build.nu | 11 +- .../parsers/windmill-parser-wasm/src/lib.rs | 5 + .../wasm-sysroot/string.h | 4 + .../wasm-sysroot/wctype.h | 6 + backend/parsers/windmill-parser/src/lib.rs | 30 +- backend/src/main.rs | 11 +- backend/src/monitor.rs | 96 + backend/tests/worker.rs | 6 + backend/windmill-api-client/codegen.rs | 7 + backend/windmill-api-client/src/codegen.rs | 2700 ++++++++++++++--- backend/windmill-api/openapi.yaml | 3 +- backend/windmill-api/src/scripts.rs | 1 + backend/windmill-api/src/workspaces_export.rs | 1 + backend/windmill-common/src/error.rs | 7 + .../windmill-common/src/global_settings.rs | 5 + backend/windmill-common/src/schema.rs | 2 +- backend/windmill-common/src/scripts.rs | 7 +- backend/windmill-common/src/worker.rs | 7 + backend/windmill-worker/Cargo.toml | 2 + .../nsjail/download.ruby.config.proto | 86 + .../nsjail/lock.ruby.config.proto | 79 + .../nsjail/run.ruby.config.proto | 113 + backend/windmill-worker/src/common.rs | 561 +--- backend/windmill-worker/src/java_executor.rs | 34 +- backend/windmill-worker/src/lib.rs | 4 + backend/windmill-worker/src/ruby_executor.rs | 899 ++++++ .../src/universal_pkg_installer.rs | 767 +++++ .../windmill-worker/src/windmill-client.js | 1 + backend/windmill-worker/src/worker.rs | 41 +- .../windmill-worker/src/worker_lockfiles.rs | 27 +- cli/bootstrap/script_bootstrap.ts | 5 + cli/dnt.ts | 2 + cli/src/commands/script/script.ts | 7 +- cli/src/commands/sync/sync.ts | 3 +- cli/src/types.ts | 1 + cli/src/utils/metadata.ts | 5 +- cli/src/utils/script_common.ts | 5 +- cli/wasm/ruby/windmill_parser_wasm.d.ts | 3 + cli/wasm/ruby/windmill_parser_wasm.js | 121 + cli/wasm/ruby/windmill_parser_wasm_bg.wasm | Bin 0 -> 1853693 bytes .../ruby/windmill_parser_wasm_bg.wasm.d.ts | 35 + docker/DockerfileFull | 3 + docker/DockerfileFullEe | 3 + docker/DockerfileNsjail | 3 + docker/dev.nu | 3 + flake.nix | 11 +- frontend/package-lock.json | 11 + frontend/package.json | 3 +- frontend/src/lib/components/Editor.svelte | 1 - frontend/src/lib/components/EditorBar.svelte | 21 +- .../src/lib/components/HighlightCode.svelte | 7 +- .../src/lib/components/ScriptBuilder.svelte | 2 +- .../common/languageIcons/LanguageIcon.svelte | 7 +- .../src/lib/components/icons/RubyIcon.svelte | 661 ++++ .../src/lib/components/instanceSettings.ts | 9 + frontend/src/lib/components/worker_group.ts | 8 +- frontend/src/lib/editorLangUtils.ts | 2 + frontend/src/lib/editorUtils.ts | 2 - frontend/src/lib/infer.ts | 10 +- frontend/src/lib/script_helpers.ts | 60 +- frontend/src/lib/scripts.ts | 5 +- .../(root)/(logged)/run/[...run]/+page.svelte | 2 +- 87 files changed, 6561 insertions(+), 1056 deletions(-) create mode 100644 backend/.sqlx/query-4fb3881cdbb4b9e93e28f460a9b3715bdc6a52b76c89f3a3913023b13c4e085c.json create mode 100644 backend/.sqlx/query-f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7.json create mode 100644 backend/migrations/20250721160151_add_ruby.down.sql create mode 100644 backend/migrations/20250721160151_add_ruby.up.sql create mode 100644 backend/parsers/windmill-parser-ruby/Cargo.toml create mode 100644 backend/parsers/windmill-parser-ruby/src/lib.rs create mode 100644 backend/parsers/windmill-parser-ruby/src/wasm_libc.rs create mode 100644 backend/windmill-worker/nsjail/download.ruby.config.proto create mode 100644 backend/windmill-worker/nsjail/lock.ruby.config.proto create mode 100644 backend/windmill-worker/nsjail/run.ruby.config.proto create mode 100644 backend/windmill-worker/src/ruby_executor.rs create mode 100644 backend/windmill-worker/src/universal_pkg_installer.rs create mode 100644 cli/wasm/ruby/windmill_parser_wasm.d.ts create mode 100644 cli/wasm/ruby/windmill_parser_wasm.js create mode 100644 cli/wasm/ruby/windmill_parser_wasm_bg.wasm create mode 100644 cli/wasm/ruby/windmill_parser_wasm_bg.wasm.d.ts create mode 100644 frontend/src/lib/components/icons/RubyIcon.svelte diff --git a/backend/.sqlx/query-0937e25e89959447e7cb1816c112bbc4718cbb8ad6e2f13eae6b14f129d12936.json b/backend/.sqlx/query-0937e25e89959447e7cb1816c112bbc4718cbb8ad6e2f13eae6b14f129d12936.json index 152ae38fdc..60d2cfdc01 100644 --- a/backend/.sqlx/query-0937e25e89959447e7cb1816c112bbc4718cbb8ad6e2f13eae6b14f129d12936.json +++ b/backend/.sqlx/query-0937e25e89959447e7cb1816c112bbc4718cbb8ad6e2f13eae6b14f129d12936.json @@ -62,7 +62,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-1a54356c1e1353950bf6ab1d25ab21270131e9e93ca10d195664e7e5a774fe9e.json b/backend/.sqlx/query-1a54356c1e1353950bf6ab1d25ab21270131e9e93ca10d195664e7e5a774fe9e.json index e8b39caef7..9462f9b48b 100644 --- a/backend/.sqlx/query-1a54356c1e1353950bf6ab1d25ab21270131e9e93ca10d195664e7e5a774fe9e.json +++ b/backend/.sqlx/query-1a54356c1e1353950bf6ab1d25ab21270131e9e93ca10d195664e7e5a774fe9e.json @@ -43,7 +43,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-48242fc46cb8bc9e4d41c788568634619565e4ef342051af23760c11edac5ee8.json b/backend/.sqlx/query-48242fc46cb8bc9e4d41c788568634619565e4ef342051af23760c11edac5ee8.json index b2d146291b..eafb17af4e 100644 --- a/backend/.sqlx/query-48242fc46cb8bc9e4d41c788568634619565e4ef342051af23760c11edac5ee8.json +++ b/backend/.sqlx/query-48242fc46cb8bc9e4d41c788568634619565e4ef342051af23760c11edac5ee8.json @@ -32,7 +32,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-488dd591096b2b47787afdc3a1d73917ed13269f2ee20b86df79fca2c8efe672.json b/backend/.sqlx/query-488dd591096b2b47787afdc3a1d73917ed13269f2ee20b86df79fca2c8efe672.json index 561e202d1d..5f59450dc3 100644 --- a/backend/.sqlx/query-488dd591096b2b47787afdc3a1d73917ed13269f2ee20b86df79fca2c8efe672.json +++ b/backend/.sqlx/query-488dd591096b2b47787afdc3a1d73917ed13269f2ee20b86df79fca2c8efe672.json @@ -71,7 +71,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-4aaab98ebdaa90f1edf49ac96fba6c391c4d0054a618b861464ee37239f1f1e0.json b/backend/.sqlx/query-4aaab98ebdaa90f1edf49ac96fba6c391c4d0054a618b861464ee37239f1f1e0.json index 91512257cd..e16cd7db75 100644 --- a/backend/.sqlx/query-4aaab98ebdaa90f1edf49ac96fba6c391c4d0054a618b861464ee37239f1f1e0.json +++ b/backend/.sqlx/query-4aaab98ebdaa90f1edf49ac96fba6c391c4d0054a618b861464ee37239f1f1e0.json @@ -138,7 +138,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-4fb3881cdbb4b9e93e28f460a9b3715bdc6a52b76c89f3a3913023b13c4e085c.json b/backend/.sqlx/query-4fb3881cdbb4b9e93e28f460a9b3715bdc6a52b76c89f3a3913023b13c4e085c.json new file mode 100644 index 0000000000..9709a354cf --- /dev/null +++ b/backend/.sqlx/query-4fb3881cdbb4b9e93e28f460a9b3715bdc6a52b76c89f3a3913023b13c4e085c.json @@ -0,0 +1,15 @@ +{ + "db_name": "PostgreSQL", + "query": "INSERT INTO pip_resolution_cache (hash, lockfile, expiration) VALUES ($1, $2, now() + ('3 days')::interval) ON CONFLICT (hash) DO UPDATE SET lockfile = $2", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Varchar", + "Text" + ] + }, + "nullable": [] + }, + "hash": "4fb3881cdbb4b9e93e28f460a9b3715bdc6a52b76c89f3a3913023b13c4e085c" +} diff --git a/backend/.sqlx/query-61c29d684e8e683e839a6d7210b3b9b96854e5bfd752e45922c358c42ebea0c4.json b/backend/.sqlx/query-61c29d684e8e683e839a6d7210b3b9b96854e5bfd752e45922c358c42ebea0c4.json index 1a30ad011f..9560d17efa 100644 --- a/backend/.sqlx/query-61c29d684e8e683e839a6d7210b3b9b96854e5bfd752e45922c358c42ebea0c4.json +++ b/backend/.sqlx/query-61c29d684e8e683e839a6d7210b3b9b96854e5bfd752e45922c358c42ebea0c4.json @@ -62,7 +62,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-804fc11e35f4afc0db194b6fe2594f91df7e588d4d2431bc85f4d8734920c8bf.json b/backend/.sqlx/query-804fc11e35f4afc0db194b6fe2594f91df7e588d4d2431bc85f4d8734920c8bf.json index 7933311a4c..6f08d98113 100644 --- a/backend/.sqlx/query-804fc11e35f4afc0db194b6fe2594f91df7e588d4d2431bc85f4d8734920c8bf.json +++ b/backend/.sqlx/query-804fc11e35f4afc0db194b6fe2594f91df7e588d4d2431bc85f4d8734920c8bf.json @@ -35,7 +35,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-a6608d47b96d851eb7b04d2e4b472889ff257db0f0e3e9252adda2e4ef2039d6.json b/backend/.sqlx/query-a6608d47b96d851eb7b04d2e4b472889ff257db0f0e3e9252adda2e4ef2039d6.json index 17dc7cfd2e..5f6611dae6 100644 --- a/backend/.sqlx/query-a6608d47b96d851eb7b04d2e4b472889ff257db0f0e3e9252adda2e4ef2039d6.json +++ b/backend/.sqlx/query-a6608d47b96d851eb7b04d2e4b472889ff257db0f0e3e9252adda2e4ef2039d6.json @@ -148,7 +148,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json b/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json index a3cb5a82b9..279d2f25fa 100644 --- a/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json +++ b/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json @@ -37,7 +37,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-a9db7b2f435bb82acb8c5eeb7f800b28f3256491fdaa168591adc7b4b9f3327a.json b/backend/.sqlx/query-a9db7b2f435bb82acb8c5eeb7f800b28f3256491fdaa168591adc7b4b9f3327a.json index 16fea8720d..c2c6738167 100644 --- a/backend/.sqlx/query-a9db7b2f435bb82acb8c5eeb7f800b28f3256491fdaa168591adc7b4b9f3327a.json +++ b/backend/.sqlx/query-a9db7b2f435bb82acb8c5eeb7f800b28f3256491fdaa168591adc7b4b9f3327a.json @@ -42,7 +42,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-ab04cda71f8e2be9acbecabe1ee5ef756b8e5c1955fbe111df9ee171dc262338.json b/backend/.sqlx/query-ab04cda71f8e2be9acbecabe1ee5ef756b8e5c1955fbe111df9ee171dc262338.json index c8cbb8e10d..072bc63b66 100644 --- a/backend/.sqlx/query-ab04cda71f8e2be9acbecabe1ee5ef756b8e5c1955fbe111df9ee171dc262338.json +++ b/backend/.sqlx/query-ab04cda71f8e2be9acbecabe1ee5ef756b8e5c1955fbe111df9ee171dc262338.json @@ -66,7 +66,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-acfe583fe17604ba72ba4800b62a72de0a9de0d58ef8c28dd709adf3be021597.json b/backend/.sqlx/query-acfe583fe17604ba72ba4800b62a72de0a9de0d58ef8c28dd709adf3be021597.json index 7d7eef1cab..fbd4571adc 100644 --- a/backend/.sqlx/query-acfe583fe17604ba72ba4800b62a72de0a9de0d58ef8c28dd709adf3be021597.json +++ b/backend/.sqlx/query-acfe583fe17604ba72ba4800b62a72de0a9de0d58ef8c28dd709adf3be021597.json @@ -71,7 +71,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/.sqlx/query-f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7.json b/backend/.sqlx/query-f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7.json new file mode 100644 index 0000000000..fb865ca894 --- /dev/null +++ b/backend/.sqlx/query-f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7.json @@ -0,0 +1,248 @@ +{ + "db_name": "PostgreSQL", + "query": "SELECT\n cj.id AS \"id!\",\n cj.workspace_id AS \"workspace_id!\",\n cj.parent_job,\n cj.created_by AS \"created_by!\",\n cj.duration_ms AS \"duration_ms!\",\n cj.success AS \"success!\",\n cj.script_hash AS \"script_hash!: Option\",\n cj.script_path,\n cj.args AS \"args: sqlx::types::Json>>\",\n cj.result AS \"result: sqlx::types::Json>\",\n cj.deleted AS \"deleted!\",\n cj.canceled AS \"canceled!\",\n cj.canceled_by,\n cj.canceled_reason,\n cj.job_kind AS \"job_kind!: JobKind\",\n cj.schedule_path,\n cj.permissioned_as AS \"permissioned_as!\",\n cj.is_flow_step AS \"is_flow_step!\",\n cj.language AS \"language: ScriptLang\",\n cj.is_skipped AS \"is_skipped!\",\n cj.email AS \"email!\",\n cj.visible_to_owner AS \"visible_to_owner!\",\n cj.mem_peak,\n cj.tag AS \"tag!\",\n cj.created_at AS \"created_at!\",\n cj.started_at,\n job_logs.logs,\n job_logs.log_offset AS \"log_offset?\",\n job_logs.log_file_index\n\n FROM v2_as_completed_job AS cj\n LEFT JOIN job_logs ON cj.id = job_logs.job_id\n WHERE cj.created_at < $1\n ORDER BY cj.created_at ASC LIMIT $2", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id!", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "workspace_id!", + "type_info": "Varchar" + }, + { + "ordinal": 2, + "name": "parent_job", + "type_info": "Uuid" + }, + { + "ordinal": 3, + "name": "created_by!", + "type_info": "Varchar" + }, + { + "ordinal": 4, + "name": "duration_ms!", + "type_info": "Int8" + }, + { + "ordinal": 5, + "name": "success!", + "type_info": "Bool" + }, + { + "ordinal": 6, + "name": "script_hash!: Option", + "type_info": "Int8" + }, + { + "ordinal": 7, + "name": "script_path", + "type_info": "Varchar" + }, + { + "ordinal": 8, + "name": "args: sqlx::types::Json>>", + "type_info": "Jsonb" + }, + { + "ordinal": 9, + "name": "result: sqlx::types::Json>", + "type_info": "Jsonb" + }, + { + "ordinal": 10, + "name": "deleted!", + "type_info": "Bool" + }, + { + "ordinal": 11, + "name": "canceled!", + "type_info": "Bool" + }, + { + "ordinal": 12, + "name": "canceled_by", + "type_info": "Varchar" + }, + { + "ordinal": 13, + "name": "canceled_reason", + "type_info": "Text" + }, + { + "ordinal": 14, + "name": "job_kind!: JobKind", + "type_info": { + "Custom": { + "name": "job_kind", + "kind": { + "Enum": [ + "script", + "preview", + "flow", + "dependencies", + "flowpreview", + "script_hub", + "identity", + "flowdependencies", + "http", + "graphql", + "postgresql", + "noop", + "appdependencies", + "deploymentcallback", + "singlescriptflow", + "flowscript", + "flownode", + "appscript" + ] + } + } + } + }, + { + "ordinal": 15, + "name": "schedule_path", + "type_info": "Varchar" + }, + { + "ordinal": 16, + "name": "permissioned_as!", + "type_info": "Varchar" + }, + { + "ordinal": 17, + "name": "is_flow_step!", + "type_info": "Bool" + }, + { + "ordinal": 18, + "name": "language: ScriptLang", + "type_info": { + "Custom": { + "name": "script_lang", + "kind": { + "Enum": [ + "python3", + "deno", + "go", + "bash", + "postgresql", + "nativets", + "bun", + "mysql", + "bigquery", + "snowflake", + "graphql", + "powershell", + "mssql", + "php", + "bunnative", + "rust", + "ansible", + "csharp", + "oracledb", + "nu", + "java", + "duckdb", + "ruby" + ] + } + } + } + }, + { + "ordinal": 19, + "name": "is_skipped!", + "type_info": "Bool" + }, + { + "ordinal": 20, + "name": "email!", + "type_info": "Varchar" + }, + { + "ordinal": 21, + "name": "visible_to_owner!", + "type_info": "Bool" + }, + { + "ordinal": 22, + "name": "mem_peak", + "type_info": "Int4" + }, + { + "ordinal": 23, + "name": "tag!", + "type_info": "Varchar" + }, + { + "ordinal": 24, + "name": "created_at!", + "type_info": "Timestamptz" + }, + { + "ordinal": 25, + "name": "started_at", + "type_info": "Timestamptz" + }, + { + "ordinal": 26, + "name": "logs", + "type_info": "Text" + }, + { + "ordinal": 27, + "name": "log_offset?", + "type_info": "Int4" + }, + { + "ordinal": 28, + "name": "log_file_index", + "type_info": "TextArray" + } + ], + "parameters": { + "Left": [ + "Timestamptz", + "Int8" + ] + }, + "nullable": [ + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true + ] + }, + "hash": "f22964772dc2d67aee437bbbd08b64792c00da1d713d7ca8f9904ccce7bfdae7" +} diff --git a/backend/.sqlx/query-ff0403790674cdb07022af71c2377afbd8b3a660b3be27514b517c077c63c238.json b/backend/.sqlx/query-ff0403790674cdb07022af71c2377afbd8b3a660b3be27514b517c077c63c238.json index 4e911403de..b100feb47d 100644 --- a/backend/.sqlx/query-ff0403790674cdb07022af71c2377afbd8b3a660b3be27514b517c077c63c238.json +++ b/backend/.sqlx/query-ff0403790674cdb07022af71c2377afbd8b3a660b3be27514b517c077c63c238.json @@ -66,7 +66,8 @@ "oracledb", "nu", "java", - "duckdb" + "duckdb", + "ruby" ] } } diff --git a/backend/Cargo.lock b/backend/Cargo.lock index 1179183971..b4d024cd02 100644 --- a/backend/Cargo.lock +++ b/backend/Cargo.lock @@ -13854,6 +13854,16 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c4013970217383f67b18aef68f6fb2e8d409bc5755227092d32efb0422ba24b8" +[[package]] +name = "tree-sitter-ruby" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be0484ea4ef6bb9c575b4fdabde7e31340a8d2dbc7d52b321ac83da703249f95" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "triomphe" version = "0.1.14" @@ -15214,6 +15224,20 @@ dependencies = [ "windmill-parser", ] +[[package]] +name = "windmill-parser-ruby" +version = "1.523.0" +dependencies = [ + "anyhow", + "lazy_static", + "regex", + "serde_json", + "tree-sitter", + "tree-sitter-ruby", + "wasm-bindgen", + "windmill-parser", +] + [[package]] name = "windmill-parser-rust" version = "1.526.1" @@ -15281,6 +15305,7 @@ dependencies = [ "windmill-parser-nu", "windmill-parser-php", "windmill-parser-py", + "windmill-parser-ruby", "windmill-parser-rust", "windmill-parser-sql", "windmill-parser-ts", @@ -15427,6 +15452,7 @@ dependencies = [ "windmill-parser-php", "windmill-parser-py", "windmill-parser-py-imports", + "windmill-parser-ruby", "windmill-parser-rust", "windmill-parser-sql", "windmill-parser-ts", diff --git a/backend/Cargo.toml b/backend/Cargo.toml index e6da910ebf..8a5cc8ec0d 100644 --- a/backend/Cargo.toml +++ b/backend/Cargo.toml @@ -24,6 +24,7 @@ members = [ "./parsers/windmill-parser-csharp", "./parsers/windmill-parser-nu", "./parsers/windmill-parser-java", + "./parsers/windmill-parser-ruby", "./parsers/windmill-parser-bash", "./parsers/windmill-parser-py", "./parsers/windmill-parser-py-imports", @@ -48,7 +49,7 @@ incremental = true lto = "thin" [features] -default = [] +default = ["ruby"] private = ["windmill-api/private", "windmill-autoscaling/private", "windmill-common/private", "windmill-git-sync/private", "windmill-indexer/private", "windmill-queue/private", "windmill-worker/private"] agent_worker_server = ["windmill-api/agent_worker_server"] enterprise = ["windmill-worker/enterprise", "windmill-queue/enterprise", "windmill-api/enterprise", "dep:windmill-autoscaling", "windmill-autoscaling/enterprise", "windmill-git-sync/enterprise", "windmill-common/prometheus", "windmill-common/enterprise"] @@ -95,7 +96,8 @@ php = ["windmill-worker/php"] csharp = ["windmill-worker/csharp"] nu = ["windmill-worker/nu"] java = ["windmill-worker/java"] -all_languages = ["python", "deno_core", "rust", "mysql", "oracledb", "duckdb", "mssql", "bigquery", "csharp", "nu", "php", "java"] +ruby = ["windmill-worker/ruby"] +all_languages = ["python", "deno_core", "rust", "mysql", "oracledb", "duckdb", "mssql", "bigquery", "csharp", "nu", "php", "java", "ruby"] # For windows we have another set of languages enabled # NOTE: DuckDB is ignored because of compilation problems all_languages_windows = ["python", "deno_core", "rust", "mysql", "oracledb", "mssql", "bigquery", "csharp", "nu", "php", "java"] @@ -145,7 +147,6 @@ systemstat.workspace = true size.workspace = true strum.workspace = true - [target.'cfg(not(target_env = "msvc"))'.dependencies] tikv-jemallocator = { optional = true, workspace = true } tikv-jemalloc-sys = { optional = true, workspace = true } @@ -180,6 +181,7 @@ windmill-parser-rust = { path = "./parsers/windmill-parser-rust" } windmill-parser-yaml = { path = "./parsers/windmill-parser-yaml" } windmill-parser-csharp = { path = "./parsers/windmill-parser-csharp" } windmill-parser-java = { path = "./parsers/windmill-parser-java" } +windmill-parser-ruby = { path = "./parsers/windmill-parser-ruby" } windmill-parser-nu = { path = "./parsers/windmill-parser-nu" } windmill-parser-bash = { path = "./parsers/windmill-parser-bash" } windmill-parser-sql = { path = "./parsers/windmill-parser-sql" } @@ -406,6 +408,7 @@ tokio-tungstenite = { version = "0.24.0", features = ["native-tls"] } tree-sitter = { version = "0.23.0", features = [] } tree-sitter-c-sharp = "0.23.0" tree-sitter-java = "0.23.0" +tree-sitter-ruby = "0.23.0" oracle = { version = "0.6.3", features = ["chrono"] } rumqttc = { version = "0.24.0", features = ["use-native-tls"]} strum = { version = "0.27", features = ["derive"] } diff --git a/backend/migrations/20250721160151_add_ruby.down.sql b/backend/migrations/20250721160151_add_ruby.down.sql new file mode 100644 index 0000000000..d2f607c5b8 --- /dev/null +++ b/backend/migrations/20250721160151_add_ruby.down.sql @@ -0,0 +1 @@ +-- Add down migration script here diff --git a/backend/migrations/20250721160151_add_ruby.up.sql b/backend/migrations/20250721160151_add_ruby.up.sql new file mode 100644 index 0000000000..3cf454718c --- /dev/null +++ b/backend/migrations/20250721160151_add_ruby.up.sql @@ -0,0 +1,3 @@ +-- Add up migration script here +ALTER TYPE SCRIPT_LANG ADD VALUE IF NOT EXISTS 'ruby'; +UPDATE config set config = jsonb_set(config, '{worker_tags}', config->'worker_tags' || '["ruby"]'::jsonb) where name = 'worker__default' and config @> '{"worker_tags": ["deno", "python3", "go", "bash", "powershell", "dependency", "flow", "hub", "other", "bun", "php", "rust", "ansible", "csharp", "nu", "java", "duckdb"]}'::jsonb AND NOT config->'worker_tags' @> '"ruby"'::jsonb; diff --git a/backend/parsers/windmill-parser-py/src/lib.rs b/backend/parsers/windmill-parser-py/src/lib.rs index 52983872c6..89ebcc659e 100644 --- a/backend/parsers/windmill-parser-py/src/lib.rs +++ b/backend/parsers/windmill-parser-py/src/lib.rs @@ -128,7 +128,7 @@ pub fn parse_python_signature( && default.is_some() && default != Some(json!(FUNCTION_CALL)) { - typ = json_to_typ(default.as_ref().unwrap()); + typ = json_to_typ(default.as_ref().unwrap(), false); } // if the type is still a list of unknowns after checking the default, we set it to a list of strings to not break past behavior diff --git a/backend/parsers/windmill-parser-ruby/Cargo.toml b/backend/parsers/windmill-parser-ruby/Cargo.toml new file mode 100644 index 0000000000..779b0116a0 --- /dev/null +++ b/backend/parsers/windmill-parser-ruby/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "windmill-parser-ruby" +version.workspace = true +edition.workspace = true +authors.workspace = true + +[lib] +name = "windmill_parser_ruby" +path = "./src/lib.rs" + +[dependencies] +windmill-parser.workspace = true +tree-sitter.workspace = true +tree-sitter-ruby.workspace = true +anyhow.workspace = true +wasm-bindgen.workspace = true +serde_json.workspace = true +regex.workspace = true +lazy_static.workspace = true diff --git a/backend/parsers/windmill-parser-ruby/src/lib.rs b/backend/parsers/windmill-parser-ruby/src/lib.rs new file mode 100644 index 0000000000..c736cef86a --- /dev/null +++ b/backend/parsers/windmill-parser-ruby/src/lib.rs @@ -0,0 +1,410 @@ +#![cfg_attr(target_arch = "wasm32", feature(c_variadic))] + +#[cfg(target_arch = "wasm32")] +pub mod wasm_libc; + +use anyhow::anyhow; +use anyhow::bail; +use regex::Regex; +use serde_json::Value; +use tree_sitter::Node; +use tree_sitter::Range; +use windmill_parser::json_to_typ; +use windmill_parser::Arg; +use windmill_parser::MainArgSignature; + +pub fn parse_ruby_sig_meta(code: &str) -> anyhow::Result { + let mut parser = tree_sitter::Parser::new(); + let language = tree_sitter_ruby::LANGUAGE; + parser + .set_language(&language.into()) + .map_err(|e| anyhow!("Error setting Ruby as language: {e}"))?; + + // Parse code + let tree = parser + .parse(code, None) + .ok_or(anyhow!("Failed to parse code"))?; + let root_node = tree.root_node(); + + root_node.clone().to_string(); + // Traverse the AST to find the Main method signature + let args = find_main_signature(root_node, code)?; + let no_main_func = Some(args.is_none()); + + let main_sig = MainArgSignature { + star_args: false, + star_kwargs: false, + args: args.unwrap_or_default(), + has_preprocessor: None, + no_main_func, + }; + + Ok(main_sig) +} + +pub fn parse_ruby_signature(code: &str) -> anyhow::Result { + Ok(parse_ruby_sig_meta(code)?) +} + +pub fn parse_ruby_requirements(code: &str) -> anyhow::Result { + let mut parser = tree_sitter::Parser::new(); + let language = tree_sitter_ruby::LANGUAGE; + parser + .set_language(&language.into()) + .map_err(|e| anyhow!("Error setting Ruby as language: {e}"))?; + + // Parse code + let tree = parser + .parse(code, None) + .ok_or(anyhow!("Failed to parse code"))?; + let root_node = tree.root_node(); + + root_node.clone().to_string(); + let mut cursor = root_node.walk(); + 'top_level: for x in root_node.children(&mut cursor) { + if x.kind() == "call" { + for (i, n) in x.children(&mut x.walk()).enumerate() { + if i == 0 + && n.kind() == "identifier" + && !n + .utf8_text(code.as_bytes()) + .map(|ident| ident == "gemfile") + .unwrap_or_default() + { + continue 'top_level; + } else if n.kind() == "do_block" { + let req = n.utf8_text(code.as_bytes())?.to_owned(); + + lazy_static::lazy_static! { + static ref WINDMILL_RE: Regex = Regex::new(r"(?m)^\s*require\s*'windmill/inline'").unwrap(); + } + + if WINDMILL_RE.find(&code).is_none() { + return Err(anyhow!( + "`require 'windmill/inline'` is not detected - please add `require 'windmill/inline'` in order to use inline gemfile. + Your Gemfile syntax will be compatible with bundler/inline." + ) + .into()); + } + + return req + // gemfile do_block comes with 'do' and 'end' + // we want to omit these by taking slice + .get(2..(req.len() - 3)) + .map(str::to_owned) + .ok_or(anyhow!("Invalid gemfile do block")); + } + } + } + } + Ok(String::new()) +} + +// Function to find the Main method's signature +fn find_main_signature<'a>(root_node: Node<'a>, code: &str) -> anyhow::Result>> { + let mut cursor = root_node.walk(); + 'top_level: for x in root_node.children(&mut cursor) { + if x.kind() == "method" { + let mut args = vec![]; + for (i, m) in x.children(&mut x.walk()).skip(1).enumerate() { + if i == 0 + && m.kind() == "identifier" + && !m + .utf8_text(code.as_bytes()) + .map(|ident| ident == "main") + .unwrap_or_default() + { + continue 'top_level; + } else if m.kind() == "method_parameters" { + for a in m.children(&mut m.walk()) { + if a.kind() == "identifier" { + a.utf8_text(code.as_bytes()).inspect(|name| { + args.push(Arg { name: (*name).to_owned(), ..Default::default() }) + })?; + } + if a.kind() == "optional_parameter" { + let mut walk = a.walk(); + let mut it = a.children(&mut walk).into_iter(); + match (it.next().and_then(|n| n.utf8_text(code.as_bytes()).ok()), { + // Skip `=` + it.next(); + it.next().map(|n| n.range()) + }) { + (Some(ident), Some(Range { start_byte, end_byte, .. })) => { + let unparsed = + &code[start_byte..end_byte].replace("nil", "null"); + let default: Value = serde_json::from_str(unparsed).map_err( + |e| + anyhow!("Cannot convert default value to json\n\tvalue: {unparsed}\n\terror: {e}{}", + if e.to_string().contains("key must be a string") { + "\n\nNOTE: If you are trying to declare default hash, use following syntax:\n { \"\": }" + } else { + "" + } + ))?; + args.push(Arg { + name: ident.to_owned(), + typ: json_to_typ(&default, true), + default: Some(default), + has_default: true, + ..Default::default() + }); + } + _ => { + let Range { start_byte, end_byte, .. } = a.range(); + bail!( + "Cannot parse optional parameter: {}", + &code.get(start_byte..end_byte).unwrap_or("CANNOT DISPLAY") + ) + } + } + } + let kind = a.kind(); + if matches!( + kind, + "keyword_parameter" | "splat_parameter" | "hash_splat_parameter" + ) { + let Range { start_byte, end_byte, .. } = a.range(); + bail!( + " - {}\n{}s are not supported", + &code.get(start_byte..end_byte).unwrap_or("CANNOT DISPLAY"), + kind.replace("_", " ") + ); + } + } + } + } + return Ok(Some(args)); + } + } + Ok(None) +} + +#[cfg(test)] +mod test { + + use serde_json::json; + use windmill_parser::{ObjectProperty, ObjectType, Typ}; + + use super::parse_ruby_sig_meta as parse; + use super::*; + #[test] + fn test_parse_ruby_no_main() { + let code = r#" +def not_main end +def private_fn end +"#; + let sig = parse(code).unwrap(); + + assert_eq!( + sig, + MainArgSignature { no_main_func: Some(true), ..Default::default() } + ); + } + #[test] + fn test_parse_ruby_no_args() { + let code = r#" +def main +end +"#; + let sig = parse(code).unwrap(); + + assert_eq!( + sig, + MainArgSignature { no_main_func: Some(false), ..Default::default() } + ); + } + #[test] + fn test_parse_ruby_positional_args() { + let sig = { + let code = r#"def main(a, b, c) end"#; + parse(code).unwrap() + }; + let sig2 = { + let code = r#" + def main a, b, c + end"#; + parse(code).unwrap() + }; + + assert_eq!( + sig, + MainArgSignature { + args: vec![ + Arg { name: "a".into(), ..Default::default() }, + Arg { name: "b".into(), ..Default::default() }, + Arg { name: "c".into(), ..Default::default() } + ], + no_main_func: Some(false), + ..Default::default() + } + ); + assert_eq!(sig2, sig); + } + #[test] + fn test_parse_ruby_lists() { + let sig = { + let code = r#"def main(a = [ 1, 2, 3 ], b = [ 1, false, nil, "test"]) end"#; + parse(code).unwrap() + }; + assert_eq!( + sig, + MainArgSignature { + args: vec![ + Arg { + name: "a".into(), + has_default: true, + typ: Typ::List(Box::new(Typ::Int)), + default: Some(json!([1, 2, 3])), + ..Default::default() + }, + Arg { + name: "b".into(), + has_default: true, + typ: Typ::List(Box::new(Typ::Unknown)), + default: Some(json!([1, false, null, "test"])), + ..Default::default() + }, + ], + no_main_func: Some(false), + ..Default::default() + } + ); + } + #[test] + fn test_parse_ruby_hashes() { + let sig = { + let code = r#"def main(a = { "1": 4, "2": [ 1, 2, 3] }) end"#; + parse(code).unwrap() + }; + assert_eq!( + sig, + MainArgSignature { + args: vec![Arg { + name: "a".into(), + has_default: true, + typ: Typ::Object(ObjectType::new( + None, + Some(vec![ + ObjectProperty { key: "1".into(), typ: Box::new(Typ::Int) }, + ObjectProperty { + key: "2".into(), + typ: Box::new(Typ::List(Box::new(Typ::Int))) + } + ],) + )), + default: Some(json!({"1": 4, "2": [ 1, 2, 3 ]})), + ..Default::default() + },], + no_main_func: Some(false), + ..Default::default() + } + ); + } + #[test] + fn test_parse_ruby_default_args() { + let sig = { + let code = + r#"def main(a = 10, b = "hey", c = false, d = [ 1, 2, 3 ], e = { "a": 43 }) end"#; + parse(code).unwrap() + }; + + assert_eq!( + sig, + MainArgSignature { + args: vec![ + Arg { + name: "a".into(), + has_default: true, + typ: Typ::Int, + default: Some(json!(10)), + ..Default::default() + }, + Arg { + name: "b".into(), + has_default: true, + typ: Typ::Str(None), + default: Some(json!("hey")), + ..Default::default() + }, + Arg { + name: "c".into(), + has_default: true, + typ: Typ::Bool, + default: Some(json!(false)), + ..Default::default() + }, + Arg { + name: "d".into(), + has_default: true, + typ: Typ::List(Box::new(Typ::Int)), + default: Some(json!([1, 2, 3])), + ..Default::default() + }, + Arg { + name: "e".into(), + has_default: true, + typ: Typ::Object(ObjectType::new( + None, + Some(vec![ObjectProperty { + key: "a".into(), + typ: Box::new(Typ::Int) + }]) + )), + default: Some(json!({"a": 43})), + ..Default::default() + }, + ], + no_main_func: Some(false), + ..Default::default() + } + ); + } + + #[test] + fn test_parse_ruby_unsupported() { + assert_eq!( + &parse("def main( a: ) end").unwrap_err().to_string(), + " - a:\nkeyword parameters are not supported" + ); + + assert_eq!( + &parse("def main( *a ) end").unwrap_err().to_string(), + " - *a\nsplat parameters are not supported" + ); + + assert_eq!( + &parse("def main( **a ) end").unwrap_err().to_string(), + " - **a\nhash splat parameters are not supported" + ); + + assert!(&parse("def main( a = Time.now ) end").is_err()); + assert!(&parse("def main( a = :symbol ) end").is_err()); + assert!(&parse("def main( a = { b: 2 } ) end").is_err()); + assert!(&parse("def main( a = { b => 2 } ) end").is_err()); + assert!(&parse(r#"def main( a = { "b" => 2 } ) end"#).is_err()); + } + + // #[test] + // fn test_parse_ruby_requirements() { + // assert_eq!( + // parse_ruby_requirements( + // " + // require 'dep1' + // require 'dep2' + // require 'dep2/submod' + // require 'u/username/script' + // require 'f/folder/script' + // " + // ) + // .unwrap(), + // vec![ + // "dep1".to_owned(), + // "dep2".into(), + // "dep2".into(), + // "u/username/script".into(), + // "f/folder/script".into(), + // ] + // ); + // } +} diff --git a/backend/parsers/windmill-parser-ruby/src/wasm_libc.rs b/backend/parsers/windmill-parser-ruby/src/wasm_libc.rs new file mode 100644 index 0000000000..ddb6705023 --- /dev/null +++ b/backend/parsers/windmill-parser-ruby/src/wasm_libc.rs @@ -0,0 +1,297 @@ +use std::collections::BTreeMap; +use std::sync::{Mutex, OnceLock}; +use std::{ + alloc::{self, Layout}, + ffi::{c_char, c_int, c_void}, + mem::align_of, + ptr, +}; +use wasm_bindgen::prelude::*; + +/* -------------------------------- stdlib.h -------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn abort() { + panic!("Aborted from C"); +} + +macro_rules! console_log { + ($($t:tt)*) => (unsafe { log(&format_args!($($t)*).to_string()) }) +} + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(js_namespace = console)] + fn log(a: &str); +} + +#[no_mangle] +pub unsafe extern "C" fn malloc(size: usize) -> *mut c_void { + if size == 0 { + return ptr::null_mut(); + } + + let (layout, offset_to_data) = layout_for_size_prepended(size); + let buf = alloc::alloc(layout); + store_layout(buf, layout, offset_to_data) +} + +#[no_mangle] +pub unsafe extern "C" fn calloc(count: usize, size: usize) -> *mut c_void { + if count == 0 || size == 0 { + return ptr::null_mut(); + } + + let (layout, offset_to_data) = layout_for_size_prepended(size * count); + let buf = alloc::alloc_zeroed(layout); + store_layout(buf, layout, offset_to_data) +} + +#[no_mangle] +pub unsafe extern "C" fn realloc(buf: *mut c_void, new_size: usize) -> *mut c_void { + if buf.is_null() { + malloc(new_size) + } else if new_size == 0 { + free(buf); + ptr::null_mut() + } else { + let (old_buf, old_layout) = retrieve_layout(buf); + let (new_layout, offset_to_data) = layout_for_size_prepended(new_size); + let new_buf = alloc::realloc(old_buf, old_layout, new_layout.size()); + store_layout(new_buf, new_layout, offset_to_data) + } +} + +#[no_mangle] +pub unsafe extern "C" fn free(buf: *mut c_void) { + if buf.is_null() { + return; + } + let (buf, layout) = retrieve_layout(buf); + alloc::dealloc(buf, layout); +} + +// In all these allocations, we store the layout before the data for later retrieval. +// This is because we need to know the layout when deallocating the memory. +// Here are some helper methods for that: + +/// Given a pointer to the data, retrieve the layout and the pointer to the layout. +unsafe fn retrieve_layout(buf: *mut c_void) -> (*mut u8, Layout) { + let (_, layout_offset) = Layout::new::() + .extend(Layout::from_size_align(0, align_of::<*const u8>() * 2).unwrap()) + .unwrap(); + + let buf = (buf as *mut u8).offset(-(layout_offset as isize)); + let layout = *(buf as *mut Layout); + + (buf, layout) +} + +/// Calculate a layout for a given size with space for storing a layout at the start. +/// Returns the layout and the offset to the data. +fn layout_for_size_prepended(size: usize) -> (Layout, usize) { + Layout::new::() + .extend(Layout::from_size_align(size, align_of::<*const u8>() * 2).unwrap()) + .unwrap() +} + +/// Store a layout in the pointer, returning a pointer to where the data should be stored. +unsafe fn store_layout(buf: *mut u8, layout: Layout, offset_to_data: usize) -> *mut c_void { + *(buf as *mut Layout) = layout; + (buf as *mut u8).offset(offset_to_data as isize) as *mut c_void +} + +/* -------------------------------- string.h -------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn strncmp(ptr1: *const c_void, ptr2: *const c_void, n: usize) -> c_int { + let s1 = std::slice::from_raw_parts(ptr1 as *const u8, n); + let s2 = std::slice::from_raw_parts(ptr2 as *const u8, n); + + for (a, b) in s1.iter().zip(s2.iter()) { + if *a != *b || *a == 0 { + return (*a as i32) - (*b as i32); + } + } + + 0 +} + +// Implementation by AI: +pub type size_t = usize; +use std::slice; +#[no_mangle] +pub unsafe extern "C" fn memchr( + haystack: *const c_void, + needle: c_int, + len: usize, +) -> *mut c_void { + if haystack.is_null() || len == 0 { + return ptr::null_mut(); // Return null if the input pointer is null or length is zero + } + + let needle_byte = needle as u8; // Convert needle to a byte + + // Create a pointer to the start of the haystack + let mut current = haystack as *const u8; + + // Iterate through the memory block + for _ in 0..len { + if *current == needle_byte { + return current as *mut c_void; // Return the pointer to the found byte + } + current = current.add(1); // Move to the next byte + } + + ptr::null_mut() // Return null if the byte was not found +} + +#[no_mangle] +pub unsafe extern "C" fn strchr(mut s: *const c_char, c: c_int) -> *mut c_char { + if s.is_null() { + return std::ptr::null_mut(); // Return null if the input string is null + } + + let target = c as u8 as char; // Convert c to a char + let mut current = s; + + // Iterate through the string until we find the character or reach the end + while *current != 0 { + if *current as u8 as char == target { + return current as *mut c_char; // Return the pointer to the found character + } + current = current.add(1); // Move to the next character + } + + std::ptr::null_mut() // Return null if the character was not found +} +// End of AI implemetation +/* -------------------------------- wctype.h -------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn iswspace(c: c_int) -> bool { + char::from_u32(c as u32).map_or(false, |c| c.is_whitespace()) +} + +#[no_mangle] +pub unsafe extern "C" fn iswalnum(c: c_int) -> bool { + char::from_u32(c as u32).map_or(false, |c| c.is_alphanumeric()) +} + +// Implementation by AI: +pub type wint_t = u32; + +#[no_mangle] +pub extern "C" fn iswdigit(wc: wint_t) -> c_int { + // Check if the character is a digit ('0' to '9') + if wc >= '0' as wint_t && wc <= '9' as wint_t { + return 1; // Return true (1) + } + 0 // Return false (0) +} + +#[no_mangle] +pub extern "C" fn iswupper(wc: wint_t) -> c_int { + // Check if the character is an uppercase letter ('A' to 'Z') + if wc >= 'A' as wint_t && wc <= 'Z' as wint_t { + return 1; // Return true (1) + } + 0 // Return false (0) +} + +#[no_mangle] +pub extern "C" fn iswalpha(wc: wint_t) -> c_int { + // Check if the character is an alphabetic character ('A' to 'Z' or 'a' to 'z') + if (wc >= 'A' as wint_t && wc <= 'Z' as wint_t) || (wc >= 'a' as wint_t && wc <= 'z' as wint_t) { + return 1; // Return true (1) + } + 0 // Return false (0) +} + +#[no_mangle] +pub extern "C" fn iswlower(wc: wint_t) -> c_int { + // Check if the character is a lowercase letter ('a' to 'z') + if wc >= 'a' as wint_t && wc <= 'z' as wint_t { + return 1; // Return true (1) + } + 0 // Return false (0) +} +// End of AI implemetation + + +/* --------------------------------- time.h --------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn clock() -> u64 { + panic!("clock is not supported"); +} + +/* --------------------------------- ctype.h -------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn isprint(c: c_int) -> bool { + c >= 32 && c <= 126 +} + +/* --------------------------------- stdio.h -------------------------------- */ + +#[no_mangle] +pub unsafe extern "C" fn fprintf(_file: *mut c_void, _format: *const c_void, _args: ...) -> c_int { + panic!("fprintf is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn fputs(_s: *const c_void, _file: *mut c_void) -> c_int { + panic!("fputs is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn fputc(_c: c_int, _file: *mut c_void) -> c_int { + panic!("fputc is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn fdopen(_fd: c_int, _mode: *const c_void) -> *mut c_void { + panic!("fdopen is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn fclose(_file: *mut c_void) -> c_int { + panic!("fclose is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn fwrite( + _ptr: *const c_void, + _size: usize, + _nmemb: usize, + _stream: *mut c_void, +) -> usize { + panic!("fwrite is not supported"); +} + +#[no_mangle] +pub unsafe extern "C" fn vsnprintf( + _buf: *mut c_char, + _size: usize, + _format: *const c_char, + _args: ... +) -> c_int { + panic!("vsnprintf is not supported"); +} + +#[no_mangle] +pub extern "C" fn clock_gettime(ptr: usize, new_size: usize) { + panic!("clock_gettime is not supported"); +} + +// int snprintf( char* restrict buffer, size_t bufsz, const char* restrict format, ... ); +#[no_mangle] +pub extern "C" fn snprintf() { + panic!("snprintf is not supported"); +} + +#[no_mangle] +pub extern "C" fn __assert_fail(_: *const i32, _: *const i32, _: *const i32, _: *const i32) { + panic!("oh no"); +} diff --git a/backend/parsers/windmill-parser-ts/src/lib.rs b/backend/parsers/windmill-parser-ts/src/lib.rs index 055dce6a81..7d998dbac7 100644 --- a/backend/parsers/windmill-parser-ts/src/lib.rs +++ b/backend/parsers/windmill-parser-ts/src/lib.rs @@ -388,7 +388,7 @@ fn parse_param( }; if typ == Typ::Unknown && dflt.is_some() { - typ = json_to_typ(dflt.as_ref().unwrap()); + typ = json_to_typ(dflt.as_ref().unwrap(), false); } Ok(Arg { otyp: None, name, typ, default: dflt, has_default: true, oidx: None }) } diff --git a/backend/parsers/windmill-parser-wasm/Cargo.toml b/backend/parsers/windmill-parser-wasm/Cargo.toml index 5b1c884143..0d60735a3a 100644 --- a/backend/parsers/windmill-parser-wasm/Cargo.toml +++ b/backend/parsers/windmill-parser-wasm/Cargo.toml @@ -29,6 +29,7 @@ ansible-parser = [ "dep:windmill-parser-yaml"] csharp-parser = [ "dep:windmill-parser-csharp"] nu-parser = [ "dep:windmill-parser-nu"] java-parser = [ "dep:windmill-parser-java"] +ruby-parser = [ "dep:windmill-parser-ruby"] [dependencies] anyhow.workspace = true @@ -45,6 +46,7 @@ windmill-parser-yaml = { workspace = true, optional = true } windmill-parser-csharp = { workspace = true, optional = true } windmill-parser-nu = { workspace = true, optional = true } windmill-parser-java = { workspace = true, optional = true } +windmill-parser-ruby = { workspace = true, optional = true } wasm-bindgen.workspace = true serde_json.workspace = true getrandom = { workspace = true, features = ["js"] } diff --git a/backend/parsers/windmill-parser-wasm/build.nu b/backend/parsers/windmill-parser-wasm/build.nu index 60fdead893..1ab87f9873 100755 --- a/backend/parsers/windmill-parser-wasm/build.nu +++ b/backend/parsers/windmill-parser-wasm/build.nu @@ -50,11 +50,11 @@ const targets = [ desc: "Java", features: "java-parser", env: "tree-sitter", - # }, { - # ident: "ruby", - # desc: "Ruby", - # features: "ruby-parser", - # env: "tree-sitter", + }, { + ident: "ruby", + desc: "Ruby", + features: "ruby-parser", + env: "tree-sitter", }, # ^^^ Add new entry here ^^^ ]; @@ -130,3 +130,4 @@ def main [ } } } + diff --git a/backend/parsers/windmill-parser-wasm/src/lib.rs b/backend/parsers/windmill-parser-wasm/src/lib.rs index e02e280abb..238b207dd2 100644 --- a/backend/parsers/windmill-parser-wasm/src/lib.rs +++ b/backend/parsers/windmill-parser-wasm/src/lib.rs @@ -168,6 +168,11 @@ pub fn parse_java(code: &str) -> String { wrap_sig(windmill_parser_java::parse_java_signature(code)) } +#[cfg(feature = "ruby-parser")] +#[wasm_bindgen] +pub fn parse_ruby(code: &str) -> String { + wrap_sig(windmill_parser_ruby::parse_ruby_signature(code)) +} #[cfg(feature = "sql-parser")] #[wasm_bindgen] pub fn parse_assets_sql(code: &str) -> String { diff --git a/backend/parsers/windmill-parser-wasm/wasm-sysroot/string.h b/backend/parsers/windmill-parser-wasm/wasm-sysroot/string.h index c0687e9c88..30fce92495 100644 --- a/backend/parsers/windmill-parser-wasm/wasm-sysroot/string.h +++ b/backend/parsers/windmill-parser-wasm/wasm-sysroot/string.h @@ -5,3 +5,7 @@ void *memmove(void *dest, const void *src, unsigned long n); void *memset(void *s, int c, unsigned long n); int memcmp(const void *ptr1, const void *ptr2, unsigned long n); int strncmp(const char *s1, const char *s2, unsigned long n); + +// Manually added (needed for Ruby) +void *memchr (void *s, int c, size_t n); +char *strchr (char *s, int c); diff --git a/backend/parsers/windmill-parser-wasm/wasm-sysroot/wctype.h b/backend/parsers/windmill-parser-wasm/wasm-sysroot/wctype.h index 517a954be5..ab0d3fd5ce 100644 --- a/backend/parsers/windmill-parser-wasm/wasm-sysroot/wctype.h +++ b/backend/parsers/windmill-parser-wasm/wasm-sysroot/wctype.h @@ -5,3 +5,9 @@ typedef __WINT_TYPE__ wint_t; int iswspace(wchar_t ch); int iswalnum(wint_t _wc); + +// Manually added (needed for Ruby) +int iswdigit(wint_t _wc); +int iswupper(wint_t _wc); +int iswalpha(wint_t _wc); +int iswlower(wint_t _wc); diff --git a/backend/parsers/windmill-parser/src/lib.rs b/backend/parsers/windmill-parser/src/lib.rs index 493222c3c3..565be52cd4 100644 --- a/backend/parsers/windmill-parser/src/lib.rs +++ b/backend/parsers/windmill-parser/src/lib.rs @@ -6,6 +6,8 @@ * LICENSE-AGPL for a copy of the license. */ +use std::mem::discriminant; + use convert_case::{Boundary, Case, Casing}; use serde::Serialize; use serde_json::Value; @@ -53,7 +55,7 @@ pub struct OneOfVariant { pub properties: Vec, } -#[derive(Serialize, Clone, Debug, PartialEq)] +#[derive(Serialize, Clone, Debug, PartialEq, Default)] #[serde(rename_all(serialize = "lowercase"))] pub enum Typ { Str(Option>), @@ -69,10 +71,11 @@ pub enum Typ { DynSelect(String), Object(ObjectType), OneOf(Vec), + #[default] Unknown, } -#[derive(Serialize, Clone, Debug, PartialEq)] +#[derive(Serialize, Clone, Debug, PartialEq, Default)] pub struct Arg { pub name: String, pub otyp: Option, @@ -82,7 +85,7 @@ pub struct Arg { pub oidx: Option, } -pub fn json_to_typ(js: &Value) -> Typ { +pub fn json_to_typ(js: &Value, precise_arrays: bool) -> Typ { match js { Value::String(_) => Typ::Str(None), Value::Number(n) if n.is_i64() => Typ::Int, @@ -92,11 +95,28 @@ pub fn json_to_typ(js: &Value) -> Typ { None, Some( o.iter() - .map(|(k, v)| ObjectProperty { key: k.to_string(), typ: Box::new(json_to_typ(v)) }) + .map(|(k, v)| ObjectProperty { + key: k.to_string(), + typ: Box::new(json_to_typ(v, precise_arrays)), + }) .collect(), ), )), - Value::Array(a) => Typ::List(Box::new(a.first().map(json_to_typ).unwrap_or(Typ::Unknown))), + Value::Array(a) => Typ::List(Box::new({ + // Check if all variant types are the same + if !precise_arrays + || a.windows(2).all(|pair| { + let (l, r) = (&pair[0], &pair[1]); + discriminant(l) == discriminant(r) + }) + { + a.first() + .map(|js| json_to_typ(js, precise_arrays)) + .unwrap_or(Typ::Unknown) + } else { + Typ::Unknown + } + })), _ => Typ::Unknown, } } diff --git a/backend/src/main.rs b/backend/src/main.rs index 02133be4d0..9b80e58eef 100644 --- a/backend/src/main.rs +++ b/backend/src/main.rs @@ -10,7 +10,7 @@ use monitor::{ load_base_url, load_otel, reload_critical_alerts_on_db_oversize, reload_delete_logs_periodically_setting, reload_indexer_config, reload_instance_python_version_setting, reload_maven_repos_setting, - reload_no_default_maven_setting, reload_nuget_config_setting, + reload_no_default_maven_setting, reload_nuget_config_setting, reload_ruby_repos_setting, reload_timeout_wait_result_setting, send_current_log_file_to_object_store, send_logs_to_object_store, WORKERS_NAMES, }; @@ -47,7 +47,7 @@ use windmill_common::{ NO_DEFAULT_MAVEN_SETTING, NPM_CONFIG_REGISTRY_SETTING, NUGET_CONFIG_SETTING, OAUTH_SETTING, OTEL_SETTING, PIP_INDEX_URL_SETTING, REQUEST_SIZE_LIMIT_SETTING, REQUIRE_PREEXISTING_USER_FOR_OAUTH_SETTING, RETENTION_PERIOD_SECS_SETTING, - SAML_METADATA_SETTING, SCIM_TOKEN_SETTING, SMTP_SETTING, TEAMS_SETTING, + RUBY_REPOS_SETTING, SAML_METADATA_SETTING, SCIM_TOKEN_SETTING, SMTP_SETTING, TEAMS_SETTING, TIMEOUT_WAIT_RESULT_SETTING, }, scripts::ScriptLang, @@ -83,7 +83,8 @@ use windmill_worker::{ get_hub_script_content_and_requirements, BUN_BUNDLE_CACHE_DIR, BUN_CACHE_DIR, CSHARP_CACHE_DIR, DENO_CACHE_DIR, DENO_CACHE_DIR_DEPS, DENO_CACHE_DIR_NPM, GO_BIN_CACHE_DIR, GO_CACHE_DIR, JAVA_CACHE_DIR, NU_CACHE_DIR, POWERSHELL_CACHE_DIR, PY310_CACHE_DIR, PY311_CACHE_DIR, - PY312_CACHE_DIR, PY313_CACHE_DIR, RUST_CACHE_DIR, TAR_JAVA_CACHE_DIR, UV_CACHE_DIR, + PY312_CACHE_DIR, PY313_CACHE_DIR, RUBY_CACHE_DIR, RUST_CACHE_DIR, TAR_JAVA_CACHE_DIR, + UV_CACHE_DIR, }; use crate::monitor::{ @@ -1014,6 +1015,9 @@ Windmill Community Edition {GIT_VERSION} NO_DEFAULT_MAVEN_SETTING => { reload_no_default_maven_setting(&conn).await }, + RUBY_REPOS_SETTING => { + reload_ruby_repos_setting(&conn).await + }, KEEP_JOB_DIR_SETTING => { load_keep_job_dir(&conn).await; }, @@ -1368,6 +1372,7 @@ pub async fn run_workers( HUB_CACHE_DIR, POWERSHELL_CACHE_DIR, JAVA_CACHE_DIR, + RUBY_CACHE_DIR, TAR_JAVA_CACHE_DIR, // for related places search: ADD_NEW_LANG ] { DirBuilder::new() diff --git a/backend/src/monitor.rs b/backend/src/monitor.rs index 2668934c8a..31f376d4b6 100644 --- a/backend/src/monitor.rs +++ b/backend/src/monitor.rs @@ -291,6 +291,7 @@ pub async fn initial_load( reload_nuget_config_setting(&conn).await; reload_maven_repos_setting(&conn).await; reload_no_default_maven_setting(&conn).await; + reload_ruby_repos_setting(&conn).await; } } @@ -1093,6 +1094,7 @@ pub async fn reload_nuget_config_setting(conn: &Connection) { ) .await; } + pub async fn reload_maven_repos_setting(conn: &Connection) { reload_option_setting_with_tracing( conn, @@ -1102,6 +1104,7 @@ pub async fn reload_maven_repos_setting(conn: &Connection) { ) .await; } + pub async fn reload_no_default_maven_setting(conn: &Connection) { let value = load_value_from_global_settings_with_conn( conn, @@ -1118,6 +1121,16 @@ pub async fn reload_no_default_maven_setting(conn: &Connection) { }; } +pub async fn reload_ruby_repos_setting(conn: &Connection) { + reload_url_list_setting_with_tracing( + conn, + windmill_common::global_settings::RUBY_REPOS_SETTING, + "RUBY_REPOS", + windmill_worker::RUBY_REPOS.clone(), + ) + .await; +} + pub async fn reload_retention_period_setting(conn: &Connection) { if let Err(e) = reload_setting( conn, @@ -1287,6 +1300,89 @@ pub async fn reload_option_setting( Ok(()) } +pub async fn reload_url_list_setting_with_tracing( + conn: &Connection, + setting_name: &str, + std_env_var: &str, + lock: Arc>>>, +) { + if let Err(e) = reload_url_list_setting(conn, setting_name, std_env_var, lock.clone()).await { + tracing::error!("Error reloading setting {}: {:?}", setting_name, e) + } +} + +pub async fn reload_url_list_setting( + conn: &Connection, + setting_name: &str, + std_env_var: &str, + lock: Arc>>>, +) -> error::Result<()> { + // Check for force environment variable + if let Ok(force_value) = std::env::var(format!("FORCE_{}", std_env_var)) { + let mut urls = Vec::new(); + for url_str in force_value.trim().split_whitespace() { + match url::Url::parse(url_str) { + Ok(url) => urls.push(url), + Err(e) => { + return Err(error::Error::BadRequest(format!("Invalid URL in FORCE_{}: '{}': {}", std_env_var, url_str, e))); + } + } + } + let mut l = lock.write().await; + *l = if urls.is_empty() { None } else { Some(urls) }; + return Ok(()); + } + + let q = load_value_from_global_settings_with_conn(conn, setting_name, true).await?; + + // Check regular environment variable + let mut value = if let Ok(env_value) = std::env::var(std_env_var) { + let mut urls = Vec::new(); + for url_str in env_value.trim().split_whitespace() { + match url::Url::parse(url_str) { + Ok(url) => urls.push(url), + Err(_) => { + // Log error but continue, similar to force variable handling + tracing::error!("Invalid URL in {}: '{}'", std_env_var, url_str); + } + } + } + if urls.is_empty() { None } else { Some(urls) } + } else { + None + }; + + // Check database setting + if let Some(q) = q { + if let Ok(repos_str) = serde_json::from_value::(q.clone()) { + let mut urls = Vec::new(); + for url_str in repos_str.trim().split_whitespace() { + match url::Url::parse(url_str) { + Ok(url) => urls.push(url), + Err(e) => { + tracing::error!("Invalid URL in {}: '{}': {}", setting_name, url_str, e); + // Continue with other URLs, just skip invalid ones + } + } + } + tracing::info!("Loaded setting {} from db config: {} URLs", setting_name, urls.len()); + value = if urls.is_empty() { None } else { Some(urls) }; + } else { + tracing::error!("Could not parse {} found: {:#?}", setting_name, &q); + } + } + + { + if value.is_none() { + tracing::info!("Loaded {} setting to None", setting_name); + } + let mut l = lock.write().await; + *l = value; + } + + Ok(()) +} + pub async fn reload_setting( conn: &Connection, setting_name: &str, diff --git a/backend/tests/worker.rs b/backend/tests/worker.rs index cce3f338dc..a8631f3484 100644 --- a/backend/tests/worker.rs +++ b/backend/tests/worker.rs @@ -3468,6 +3468,7 @@ async fn test_script_schedule_handlers(db: Pool) { tag: None, paused_until: None, cron_version: None, + description: None, }; let _ = client.create_schedule("test-workspace", &schedule).await; @@ -3538,6 +3539,7 @@ async fn test_script_schedule_handlers(db: Pool) { tag: None, paused_until: None, cron_version: None, + description: None, }, ) .await @@ -3621,6 +3623,7 @@ async fn test_flow_schedule_handlers(db: Pool) { tag: None, paused_until: None, cron_version: None, + description: None, }; let _ = client.create_schedule("test-workspace", &schedule).await; @@ -3692,6 +3695,7 @@ async fn test_flow_schedule_handlers(db: Pool) { tag: None, paused_until: None, cron_version: None, + description: None, }, ) .await @@ -3777,6 +3781,7 @@ async fn run_deployed_relative_imports( codebase: None, has_preprocessor: None, on_behalf_of_email: None, + assets: vec![], }, ) .await @@ -4028,6 +4033,7 @@ async fn assert_lockfile( codebase: None, has_preprocessor: None, on_behalf_of_email: None, + assets: vec![], }, ) .await diff --git a/backend/windmill-api-client/codegen.rs b/backend/windmill-api-client/codegen.rs index 202145159e..4de622c668 100644 --- a/backend/windmill-api-client/codegen.rs +++ b/backend/windmill-api-client/codegen.rs @@ -8213,6 +8213,9 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Csharp, #[serde(rename = "nu")] Nu, + #[serde(rename = "ruby")] + Ruby, + // for related places search: ADD_NEW_LANG } impl From<&ScriptLang> for ScriptLang { fn from(value: &ScriptLang) -> Self { @@ -8241,6 +8244,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::Ansible => "ansible".to_string(), Self::Csharp => "csharp".to_string(), Self::Nu => "nu".to_string(), + Self::Ruby => "ruby".to_string(), + // for related places search: ADD_NEW_LANG } } } @@ -8267,6 +8272,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK "ansible" => Ok(Self::Ansible), "csharp" => Ok(Self::Csharp), "nu" => Ok(Self::Nu), + "ruby" => Ok(Self::Ruby), + // for related places search: ADD_NEW_LANG _ => Err("invalid value"), } } diff --git a/backend/windmill-api-client/src/codegen.rs b/backend/windmill-api-client/src/codegen.rs index 9bc26262d5..2ef8fe8cac 100644 --- a/backend/windmill-api-client/src/codegen.rs +++ b/backend/windmill-api-client/src/codegen.rs @@ -7,6 +7,20 @@ pub mod types { use serde::{Deserialize, Serialize}; #[allow(unused_imports)] use std::convert::TryFrom; + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct AiConfig { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub code_completion_model: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default_model: Option, + #[serde(default, skip_serializing_if = "std::collections::HashMap::is_empty")] + pub providers: std::collections::HashMap, + } + impl From<&AiConfig> for AiConfig { + fn from(value: &AiConfig) -> Self { + value.clone() + } + } #[derive( Clone, Copy, @@ -22,6 +36,8 @@ pub mod types { pub enum AiProvider { #[serde(rename = "openai")] Openai, + #[serde(rename = "azure_openai")] + AzureOpenai, #[serde(rename = "anthropic")] Anthropic, #[serde(rename = "mistral")] @@ -34,6 +50,8 @@ pub mod types { Groq, #[serde(rename = "openrouter")] Openrouter, + #[serde(rename = "togetherai")] + Togetherai, #[serde(rename = "customai")] Customai, } @@ -46,12 +64,14 @@ pub mod types { fn to_string(&self) -> String { match *self { Self::Openai => "openai".to_string(), + Self::AzureOpenai => "azure_openai".to_string(), Self::Anthropic => "anthropic".to_string(), Self::Mistral => "mistral".to_string(), Self::Deepseek => "deepseek".to_string(), Self::Googleai => "googleai".to_string(), Self::Groq => "groq".to_string(), Self::Openrouter => "openrouter".to_string(), + Self::Togetherai => "togetherai".to_string(), Self::Customai => "customai".to_string(), } } @@ -61,12 +81,14 @@ pub mod types { fn from_str(value: &str) -> Result { match value { "openai" => Ok(Self::Openai), + "azure_openai" => Ok(Self::AzureOpenai), "anthropic" => Ok(Self::Anthropic), "mistral" => Ok(Self::Mistral), "deepseek" => Ok(Self::Deepseek), "googleai" => Ok(Self::Googleai), "groq" => Ok(Self::Groq), "openrouter" => Ok(Self::Openrouter), + "togetherai" => Ok(Self::Togetherai), "customai" => Ok(Self::Customai), _ => Err("invalid value"), } @@ -91,12 +113,35 @@ pub mod types { } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct AiResource { - pub path: String, + pub struct AiProviderConfig { + pub models: Vec, + pub resource_path: String, + } + impl From<&AiProviderConfig> for AiProviderConfig { + fn from(value: &AiProviderConfig) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct AiProviderModel { + pub model: String, pub provider: AiProvider, } - impl From<&AiResource> for AiResource { - fn from(value: &AiResource) -> Self { + impl From<&AiProviderModel> for AiProviderModel { + fn from(value: &AiProviderModel) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct Alert { + pub alert_cooldown_seconds: i64, + pub alert_time_threshold_seconds: i64, + pub jobs_num_threshold: i64, + pub name: String, + pub tags_to_monitor: Vec, + } + impl From<&Alert> for Alert { + fn from(value: &Alert) -> Self { value.clone() } } @@ -210,6 +255,201 @@ pub mod types { } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct Asset { + pub kind: AssetKind, + pub path: String, + } + impl From<&Asset> for Asset { + fn from(value: &Asset) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum AssetKind { + #[serde(rename = "s3object")] + S3object, + #[serde(rename = "resource")] + Resource, + #[serde(rename = "ducklake")] + Ducklake, + } + impl From<&AssetKind> for AssetKind { + fn from(value: &AssetKind) -> Self { + value.clone() + } + } + impl ToString for AssetKind { + fn to_string(&self) -> String { + match *self { + Self::S3object => "s3object".to_string(), + Self::Resource => "resource".to_string(), + Self::Ducklake => "ducklake".to_string(), + } + } + } + impl std::str::FromStr for AssetKind { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "s3object" => Ok(Self::S3object), + "resource" => Ok(Self::Resource), + "ducklake" => Ok(Self::Ducklake), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for AssetKind { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for AssetKind { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for AssetKind { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum AssetUsageAccessType { + #[serde(rename = "r")] + R, + #[serde(rename = "w")] + W, + #[serde(rename = "rw")] + Rw, + } + impl From<&AssetUsageAccessType> for AssetUsageAccessType { + fn from(value: &AssetUsageAccessType) -> Self { + value.clone() + } + } + impl ToString for AssetUsageAccessType { + fn to_string(&self) -> String { + match *self { + Self::R => "r".to_string(), + Self::W => "w".to_string(), + Self::Rw => "rw".to_string(), + } + } + } + impl std::str::FromStr for AssetUsageAccessType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "r" => Ok(Self::R), + "w" => Ok(Self::W), + "rw" => Ok(Self::Rw), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for AssetUsageAccessType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for AssetUsageAccessType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for AssetUsageAccessType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum AssetUsageKind { + #[serde(rename = "script")] + Script, + #[serde(rename = "flow")] + Flow, + } + impl From<&AssetUsageKind> for AssetUsageKind { + fn from(value: &AssetUsageKind) -> Self { + value.clone() + } + } + impl ToString for AssetUsageKind { + fn to_string(&self) -> String { + match *self { + Self::Script => "script".to_string(), + Self::Flow => "flow".to_string(), + } + } + } + impl std::str::FromStr for AssetUsageKind { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "script" => Ok(Self::Script), + "flow" => Ok(Self::Flow), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for AssetUsageKind { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for AssetUsageKind { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for AssetUsageKind { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct AuditLog { pub action_kind: AuditLogActionKind, pub id: i64, @@ -218,6 +458,8 @@ pub mod types { pub parameters: std::collections::HashMap, #[serde(default, skip_serializing_if = "Option::is_none")] pub resource: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub span: Option, pub timestamp: chrono::DateTime, pub username: String, } @@ -690,6 +932,81 @@ pub mod types { value.parse() } } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum AuthenticationMethod { + #[serde(rename = "none")] + None, + #[serde(rename = "windmill")] + Windmill, + #[serde(rename = "api_key")] + ApiKey, + #[serde(rename = "basic_http")] + BasicHttp, + #[serde(rename = "custom_script")] + CustomScript, + #[serde(rename = "signature")] + Signature, + } + impl From<&AuthenticationMethod> for AuthenticationMethod { + fn from(value: &AuthenticationMethod) -> Self { + value.clone() + } + } + impl ToString for AuthenticationMethod { + fn to_string(&self) -> String { + match *self { + Self::None => "none".to_string(), + Self::Windmill => "windmill".to_string(), + Self::ApiKey => "api_key".to_string(), + Self::BasicHttp => "basic_http".to_string(), + Self::CustomScript => "custom_script".to_string(), + Self::Signature => "signature".to_string(), + } + } + } + impl std::str::FromStr for AuthenticationMethod { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "none" => Ok(Self::None), + "windmill" => Ok(Self::Windmill), + "api_key" => Ok(Self::ApiKey), + "basic_http" => Ok(Self::BasicHttp), + "custom_script" => Ok(Self::CustomScript), + "signature" => Ok(Self::Signature), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for AuthenticationMethod { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for AuthenticationMethod { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for AuthenticationMethod { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct AutoscalingEvent { #[serde(default, skip_serializing_if = "Option::is_none")] @@ -710,6 +1027,65 @@ pub mod types { value.clone() } } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum AwsAuthResourceType { + #[serde(rename = "oidc")] + Oidc, + #[serde(rename = "credentials")] + Credentials, + } + impl From<&AwsAuthResourceType> for AwsAuthResourceType { + fn from(value: &AwsAuthResourceType) -> Self { + value.clone() + } + } + impl ToString for AwsAuthResourceType { + fn to_string(&self) -> String { + match *self { + Self::Oidc => "oidc".to_string(), + Self::Credentials => "credentials".to_string(), + } + } + } + impl std::str::FromStr for AwsAuthResourceType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "oidc" => Ok(Self::Oidc), + "credentials" => Ok(Self::Credentials), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for AwsAuthResourceType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for AwsAuthResourceType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for AwsAuthResourceType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct BranchAll { pub branches: Vec, @@ -874,9 +1250,8 @@ pub mod types { pub struct Capture { pub created_at: chrono::DateTime, pub id: i64, - pub payload: serde_json::Value, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub trigger_extra: Option, + pub main_args: serde_json::Value, + pub preprocessor_args: serde_json::Value, pub trigger_kind: CaptureTriggerKind, } impl From<&Capture> for Capture { @@ -930,6 +1305,8 @@ pub mod types { Sqs, #[serde(rename = "mqtt")] Mqtt, + #[serde(rename = "gcp")] + Gcp, } impl From<&CaptureTriggerKind> for CaptureTriggerKind { fn from(value: &CaptureTriggerKind) -> Self { @@ -948,6 +1325,7 @@ pub mod types { Self::Postgres => "postgres".to_string(), Self::Sqs => "sqs".to_string(), Self::Mqtt => "mqtt".to_string(), + Self::Gcp => "gcp".to_string(), } } } @@ -964,6 +1342,7 @@ pub mod types { "postgres" => Ok(Self::Postgres), "sqs" => Ok(Self::Sqs), "mqtt" => Ok(Self::Mqtt), + "gcp" => Ok(Self::Gcp), _ => Err("invalid value"), } } @@ -1064,6 +1443,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub worker: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub workflow_as_code_status: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub workspace_id: Option, } impl From<&CompletedJob> for CompletedJob { @@ -1200,6 +1581,39 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct Configs(pub Option); + impl std::ops::Deref for Configs { + type Target = Option; + fn deref(&self) -> &Option { + &self.0 + } + } + impl From for Option { + fn from(value: Configs) -> Self { + value.0 + } + } + impl From<&Configs> for Configs { + fn from(value: &Configs) -> Self { + value.clone() + } + } + impl From> for Configs { + fn from(value: Option) -> Self { + Self(value) + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct ConfigsInner { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub alerts: Vec, + } + impl From<&ConfigsInner> for ConfigsInner { + fn from(value: &ConfigsInner) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct ContextualVariable { pub description: String, pub is_custom: bool, @@ -1237,9 +1651,12 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct CreateResource { + ///The description of the resource #[serde(default, skip_serializing_if = "Option::is_none")] pub description: Option, + ///The path to the resource pub path: String, + ///The resource_type associated with the resource pub resource_type: String, pub value: serde_json::Value, } @@ -1250,15 +1667,22 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct CreateVariable { + ///The account identifier #[serde(default, skip_serializing_if = "Option::is_none")] pub account: Option, + ///The description of the variable pub description: String, + ///The expiration date of the variable #[serde(default, skip_serializing_if = "Option::is_none")] pub expires_at: Option>, + ///Whether the variable is an OAuth variable #[serde(default, skip_serializing_if = "Option::is_none")] pub is_oauth: Option, + ///Whether the variable is a secret pub is_secret: bool, + ///The path to the variable pub path: String, + ///The value of the variable pub value: String, } impl From<&CreateVariable> for CreateVariable { @@ -1307,27 +1731,11 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct EditHttpTrigger { - pub http_method: EditHttpTriggerHttpMethod, - pub is_async: bool, - pub is_flow: bool, - pub is_static_website: bool, - pub path: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub raw_string: Option, - pub requires_auth: bool, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub route_path: Option, - pub script_path: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub static_asset_config: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub workspaced_route: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub wrap_body: Option, + pub struct DeleteGcpSubscription { + pub subscription_id: String, } - impl From<&EditHttpTrigger> for EditHttpTrigger { - fn from(value: &EditHttpTrigger) -> Self { + impl From<&DeleteGcpSubscription> for DeleteGcpSubscription { + fn from(value: &DeleteGcpSubscription) -> Self { value.clone() } } @@ -1343,66 +1751,201 @@ the execution of this script will be permissioned_as and by extension its DT_TOK PartialOrd, Serialize )] - pub enum EditHttpTriggerHttpMethod { - #[serde(rename = "get")] - Get, - #[serde(rename = "post")] - Post, - #[serde(rename = "put")] - Put, - #[serde(rename = "delete")] - Delete, - #[serde(rename = "patch")] - Patch, + pub enum DeliveryType { + #[serde(rename = "push")] + Push, + #[serde(rename = "pull")] + Pull, } - impl From<&EditHttpTriggerHttpMethod> for EditHttpTriggerHttpMethod { - fn from(value: &EditHttpTriggerHttpMethod) -> Self { + impl From<&DeliveryType> for DeliveryType { + fn from(value: &DeliveryType) -> Self { value.clone() } } - impl ToString for EditHttpTriggerHttpMethod { + impl ToString for DeliveryType { fn to_string(&self) -> String { match *self { - Self::Get => "get".to_string(), - Self::Post => "post".to_string(), - Self::Put => "put".to_string(), - Self::Delete => "delete".to_string(), - Self::Patch => "patch".to_string(), + Self::Push => "push".to_string(), + Self::Pull => "pull".to_string(), } } } - impl std::str::FromStr for EditHttpTriggerHttpMethod { + impl std::str::FromStr for DeliveryType { type Err = &'static str; fn from_str(value: &str) -> Result { match value { - "get" => Ok(Self::Get), - "post" => Ok(Self::Post), - "put" => Ok(Self::Put), - "delete" => Ok(Self::Delete), - "patch" => Ok(Self::Patch), + "push" => Ok(Self::Push), + "pull" => Ok(Self::Pull), _ => Err("invalid value"), } } } - impl std::convert::TryFrom<&str> for EditHttpTriggerHttpMethod { + impl std::convert::TryFrom<&str> for DeliveryType { type Error = &'static str; fn try_from(value: &str) -> Result { value.parse() } } - impl std::convert::TryFrom<&String> for EditHttpTriggerHttpMethod { + impl std::convert::TryFrom<&String> for DeliveryType { type Error = &'static str; fn try_from(value: &String) -> Result { value.parse() } } - impl std::convert::TryFrom for EditHttpTriggerHttpMethod { + impl std::convert::TryFrom for DeliveryType { type Error = &'static str; fn try_from(value: String) -> Result { value.parse() } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct DucklakeSettings { + pub ducklakes: std::collections::HashMap, + } + impl From<&DucklakeSettings> for DucklakeSettings { + fn from(value: &DucklakeSettings) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct DucklakeSettingsDucklakesValue { + pub catalog: DucklakeSettingsDucklakesValueCatalog, + pub storage: DucklakeSettingsDucklakesValueStorage, + } + impl From<&DucklakeSettingsDucklakesValue> for DucklakeSettingsDucklakesValue { + fn from(value: &DucklakeSettingsDucklakesValue) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct DucklakeSettingsDucklakesValueCatalog { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub resource_path: Option, + pub resource_type: DucklakeSettingsDucklakesValueCatalogResourceType, + } + impl From<&DucklakeSettingsDucklakesValueCatalog> + for DucklakeSettingsDucklakesValueCatalog { + fn from(value: &DucklakeSettingsDucklakesValueCatalog) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum DucklakeSettingsDucklakesValueCatalogResourceType { + #[serde(rename = "postgresql")] + Postgresql, + #[serde(rename = "mysql")] + Mysql, + #[serde(rename = "instance")] + Instance, + } + impl From<&DucklakeSettingsDucklakesValueCatalogResourceType> + for DucklakeSettingsDucklakesValueCatalogResourceType { + fn from(value: &DucklakeSettingsDucklakesValueCatalogResourceType) -> Self { + value.clone() + } + } + impl ToString for DucklakeSettingsDucklakesValueCatalogResourceType { + fn to_string(&self) -> String { + match *self { + Self::Postgresql => "postgresql".to_string(), + Self::Mysql => "mysql".to_string(), + Self::Instance => "instance".to_string(), + } + } + } + impl std::str::FromStr for DucklakeSettingsDucklakesValueCatalogResourceType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "postgresql" => Ok(Self::Postgresql), + "mysql" => Ok(Self::Mysql), + "instance" => Ok(Self::Instance), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> + for DucklakeSettingsDucklakesValueCatalogResourceType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> + for DucklakeSettingsDucklakesValueCatalogResourceType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom + for DucklakeSettingsDucklakesValueCatalogResourceType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct DucklakeSettingsDucklakesValueStorage { + pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub storage: Option, + } + impl From<&DucklakeSettingsDucklakesValueStorage> + for DucklakeSettingsDucklakesValueStorage { + fn from(value: &DucklakeSettingsDucklakesValueStorage) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct EditHttpTrigger { + pub authentication_method: AuthenticationMethod, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub authentication_resource_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + pub http_method: HttpMethod, + pub is_async: bool, + pub is_flow: bool, + pub is_static_website: bool, + pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub raw_string: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub route_path: Option, + pub script_path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub static_asset_config: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub workspaced_route: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub wrap_body: Option, + } + impl From<&EditHttpTrigger> for EditHttpTrigger { + fn from(value: &EditHttpTrigger) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditHttpTriggerStaticAssetConfig { #[serde(default, skip_serializing_if = "Option::is_none")] pub filename: Option, @@ -1417,10 +1960,16 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditKafkaTrigger { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub group_id: String, pub is_flow: bool, pub kafka_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub topics: Vec, } @@ -1436,9 +1985,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub client_version: Option, pub enabled: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub mqtt_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub subscribe_topics: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -1455,9 +2010,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub struct EditNatsTrigger { #[serde(default, skip_serializing_if = "Option::is_none")] pub consumer_name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub nats_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub stream_name: Option, @@ -1472,6 +2033,10 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditPostgresTrigger { pub enabled: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub path: String, pub postgres_resource_path: String, @@ -1479,6 +2044,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub publication: Option, pub publication_name: String, pub replication_slot_name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, } impl From<&EditPostgresTrigger> for EditPostgresTrigger { @@ -1488,10 +2055,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditResource { + ///The new description of the resource #[serde(default, skip_serializing_if = "Option::is_none")] pub description: Option, + ///The path to the resource #[serde(default, skip_serializing_if = "Option::is_none")] pub path: Option, + ///The new resource_type to be associated with the resource + #[serde(default, skip_serializing_if = "Option::is_none")] + pub resource_type: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub value: Option, } @@ -1515,38 +2087,53 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditSchedule { pub args: ScriptArgs, + ///The version of the cron schedule to use (last is v2) #[serde(default, skip_serializing_if = "Option::is_none")] pub cron_version: Option, + ///The description of the schedule + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + ///Whether the schedule should not run if a flow is already running #[serde(default, skip_serializing_if = "Option::is_none")] pub no_flow_overlap: Option, + ///The path to the script or flow to trigger on failure #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure: Option, + ///Whether the schedule should only run on the exact time #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_exact: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_extra_args: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_times: Option, + ///The path to the script or flow to trigger on recovery #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery_extra_args: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery_times: Option, + ///The path to the script or flow to trigger on success #[serde(default, skip_serializing_if = "Option::is_none")] pub on_success: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_success_extra_args: Option, + ///The date and time the schedule will be paused until #[serde(default, skip_serializing_if = "Option::is_none")] pub paused_until: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] pub retry: Option, + ///The cron schedule to trigger the script or flow. Should include seconds. pub schedule: String, + ///The summary of the schedule #[serde(default, skip_serializing_if = "Option::is_none")] pub summary: Option, + ///The tag of the schedule #[serde(default, skip_serializing_if = "Option::is_none")] pub tag: Option, + ///The timezone to use for the cron schedule pub timezone: String, + ///Whether the WebSocket error handler is muted #[serde(default, skip_serializing_if = "Option::is_none")] pub ws_error_handler_muted: Option, } @@ -1557,13 +2144,20 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditSqsTrigger { + pub aws_auth_resource_type: AwsAuthResourceType, pub aws_resource_path: String, pub enabled: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub message_attributes: Vec, pub path: String, pub queue_url: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, } impl From<&EditSqsTrigger> for EditSqsTrigger { @@ -1573,12 +2167,16 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditVariable { + ///The new description of the variable #[serde(default, skip_serializing_if = "Option::is_none")] pub description: Option, + ///Whether the variable is a secret #[serde(default, skip_serializing_if = "Option::is_none")] pub is_secret: Option, + ///The path to the variable #[serde(default, skip_serializing_if = "Option::is_none")] pub path: Option, + ///The new value of the variable #[serde(default, skip_serializing_if = "Option::is_none")] pub value: Option, } @@ -1590,11 +2188,17 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug, Deserialize, Serialize)] pub struct EditWebsocketTrigger { pub can_return_message: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub filters: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub initial_messages: Vec, pub is_flow: bool, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub url: String, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -1630,6 +2234,104 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct EndpointTool { + ///JSON schema for request body + #[serde(default, skip_serializing_if = "Option::is_none")] + pub body_schema: Option>, + ///Short description of the tool + pub description: String, + ///Detailed instructions for using the tool + pub instructions: String, + ///HTTP method (GET, POST, etc.) + pub method: String, + ///The tool name/operation ID + pub name: String, + ///API endpoint path + pub path: String, + ///JSON schema for path parameters + #[serde(default, skip_serializing_if = "Option::is_none")] + pub path_params_schema: Option< + std::collections::HashMap, + >, + ///JSON schema for query parameters + #[serde(default, skip_serializing_if = "Option::is_none")] + pub query_params_schema: Option< + std::collections::HashMap, + >, + } + impl From<&EndpointTool> for EndpointTool { + fn from(value: &EndpointTool) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum ErrorHandler { + #[serde(rename = "custom")] + Custom, + #[serde(rename = "slack")] + Slack, + #[serde(rename = "teams")] + Teams, + #[serde(rename = "email")] + Email, + } + impl From<&ErrorHandler> for ErrorHandler { + fn from(value: &ErrorHandler) -> Self { + value.clone() + } + } + impl ToString for ErrorHandler { + fn to_string(&self) -> String { + match *self { + Self::Custom => "custom".to_string(), + Self::Slack => "slack".to_string(), + Self::Teams => "teams".to_string(), + Self::Email => "email".to_string(), + } + } + } + impl std::str::FromStr for ErrorHandler { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "custom" => Ok(Self::Custom), + "slack" => Ok(Self::Slack), + "teams" => Ok(Self::Teams), + "email" => Ok(Self::Email), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for ErrorHandler { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for ErrorHandler { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for ErrorHandler { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct ExportedInstanceGroup { #[serde(default, skip_serializing_if = "Vec::is_empty")] pub emails: Vec, @@ -1771,9 +2473,9 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub sleep: Option, #[serde(default, skip_serializing_if = "Option::is_none")] - pub stop_after_all_iters_if: Option, + pub stop_after_all_iters_if: Option, #[serde(default, skip_serializing_if = "Option::is_none")] - pub stop_after_if: Option, + pub stop_after_if: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub summary: Option, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -1809,30 +2511,6 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct FlowModuleStopAfterAllItersIf { - pub expr: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub skip_if_stopped: Option, - } - impl From<&FlowModuleStopAfterAllItersIf> for FlowModuleStopAfterAllItersIf { - fn from(value: &FlowModuleStopAfterAllItersIf) -> Self { - value.clone() - } - } - #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct FlowModuleStopAfterIf { - pub expr: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub skip_if_stopped: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub error_message: Option - } - impl From<&FlowModuleStopAfterIf> for FlowModuleStopAfterIf { - fn from(value: &FlowModuleStopAfterIf) -> Self { - value.clone() - } - } - #[derive(Clone, Debug, Deserialize, Serialize)] pub struct FlowModuleSuspend { #[serde(default, skip_serializing_if = "Option::is_none")] pub continue_on_disapprove_timeout: Option, @@ -2319,14 +2997,105 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct GitRepositorySettings { + pub struct GcpTrigger { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub delivery_config: Option, + pub delivery_type: DeliveryType, + pub enabled: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + pub gcp_resource_path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub last_server_ping: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub server_id: Option, + pub subscription_id: String, + pub subscription_mode: SubscriptionMode, + pub topic_id: String, + } + impl From<&GcpTrigger> for GcpTrigger { + fn from(value: &GcpTrigger) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GcpTriggerData { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub auto_acknowledge_msg: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub base_endpoint: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub delivery_config: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub delivery_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + pub gcp_resource_path: String, + pub is_flow: bool, + pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + pub script_path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub subscription_id: Option, + pub subscription_mode: SubscriptionMode, + pub topic_id: String, + } + impl From<&GcpTriggerData> for GcpTriggerData { + fn from(value: &GcpTriggerData) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GenerateOpenapiSpec { #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub exclude_types_override: Vec, + pub http_route_filters: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub info: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub openapi_spec_format: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub url: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub webhook_filters: Vec, + } + impl From<&GenerateOpenapiSpec> for GenerateOpenapiSpec { + fn from(value: &GenerateOpenapiSpec) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GetAllTopicSubscription { + pub topic_id: String, + } + impl From<&GetAllTopicSubscription> for GetAllTopicSubscription { + fn from(value: &GetAllTopicSubscription) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GitRepositorySettings { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub collapsed: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub exclude_types_override: Vec, pub git_repo_resource_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub group_by_folder: Option, pub script_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub settings: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub use_individual_branch: Option, } impl From<&GitRepositorySettings> for GitRepositorySettings { @@ -2334,6 +3103,22 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GitRepositorySettingsSettings { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub exclude_path: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub extra_include_path: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub include_path: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub include_type: Vec, + } + impl From<&GitRepositorySettingsSettings> for GitRepositorySettingsSettings { + fn from(value: &GitRepositorySettingsSettings) -> Self { + value.clone() + } + } #[derive( Clone, Copy, @@ -2346,7 +3131,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK PartialOrd, Serialize )] - pub enum GitRepositorySettingsExcludeTypesOverrideItem { + pub enum GitSyncObjectType { #[serde(rename = "script")] Script, #[serde(rename = "flow")] @@ -2369,14 +3154,19 @@ the execution of this script will be permissioned_as and by extension its DT_TOK User, #[serde(rename = "group")] Group, + #[serde(rename = "trigger")] + Trigger, + #[serde(rename = "settings")] + Settings, + #[serde(rename = "key")] + Key, } - impl From<&GitRepositorySettingsExcludeTypesOverrideItem> - for GitRepositorySettingsExcludeTypesOverrideItem { - fn from(value: &GitRepositorySettingsExcludeTypesOverrideItem) -> Self { + impl From<&GitSyncObjectType> for GitSyncObjectType { + fn from(value: &GitSyncObjectType) -> Self { value.clone() } } - impl ToString for GitRepositorySettingsExcludeTypesOverrideItem { + impl ToString for GitSyncObjectType { fn to_string(&self) -> String { match *self { Self::Script => "script".to_string(), @@ -2390,10 +3180,13 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::Schedule => "schedule".to_string(), Self::User => "user".to_string(), Self::Group => "group".to_string(), + Self::Trigger => "trigger".to_string(), + Self::Settings => "settings".to_string(), + Self::Key => "key".to_string(), } } } - impl std::str::FromStr for GitRepositorySettingsExcludeTypesOverrideItem { + impl std::str::FromStr for GitSyncObjectType { type Err = &'static str; fn from_str(value: &str) -> Result { match value { @@ -2408,31 +3201,79 @@ the execution of this script will be permissioned_as and by extension its DT_TOK "schedule" => Ok(Self::Schedule), "user" => Ok(Self::User), "group" => Ok(Self::Group), + "trigger" => Ok(Self::Trigger), + "settings" => Ok(Self::Settings), + "key" => Ok(Self::Key), _ => Err("invalid value"), } } } - impl std::convert::TryFrom<&str> for GitRepositorySettingsExcludeTypesOverrideItem { + impl std::convert::TryFrom<&str> for GitSyncObjectType { type Error = &'static str; fn try_from(value: &str) -> Result { value.parse() } } - impl std::convert::TryFrom<&String> - for GitRepositorySettingsExcludeTypesOverrideItem { + impl std::convert::TryFrom<&String> for GitSyncObjectType { type Error = &'static str; fn try_from(value: &String) -> Result { value.parse() } } - impl std::convert::TryFrom - for GitRepositorySettingsExcludeTypesOverrideItem { + impl std::convert::TryFrom for GitSyncObjectType { type Error = &'static str; fn try_from(value: String) -> Result { value.parse() } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GithubInstallations(pub Vec); + impl std::ops::Deref for GithubInstallations { + type Target = Vec; + fn deref(&self) -> &Vec { + &self.0 + } + } + impl From for Vec { + fn from(value: GithubInstallations) -> Self { + value.0 + } + } + impl From<&GithubInstallations> for GithubInstallations { + fn from(value: &GithubInstallations) -> Self { + value.clone() + } + } + impl From> for GithubInstallations { + fn from(value: Vec) -> Self { + Self(value) + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GithubInstallationsItem { + pub account_id: String, + pub installation_id: f64, + pub repositories: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub workspace_id: Option, + } + impl From<&GithubInstallationsItem> for GithubInstallationsItem { + fn from(value: &GithubInstallationsItem) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct GithubInstallationsItemRepositoriesItem { + pub name: String, + pub url: String, + } + impl From<&GithubInstallationsItemRepositoriesItem> + for GithubInstallationsItemRepositoriesItem { + fn from(value: &GithubInstallationsItemRepositoriesItem) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct GlobalSetting { pub name: String, pub value: std::collections::HashMap, @@ -2538,24 +3379,6 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } - #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct HttpTrigger { - pub http_method: HttpTriggerHttpMethod, - pub is_async: bool, - pub is_static_website: bool, - pub raw_string: bool, - pub requires_auth: bool, - pub route_path: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub static_asset_config: Option, - pub workspaced_route: bool, - pub wrap_body: bool, - } - impl From<&HttpTrigger> for HttpTrigger { - fn from(value: &HttpTrigger) -> Self { - value.clone() - } - } #[derive( Clone, Copy, @@ -2568,7 +3391,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK PartialOrd, Serialize )] - pub enum HttpTriggerHttpMethod { + pub enum HttpMethod { #[serde(rename = "get")] Get, #[serde(rename = "post")] @@ -2580,12 +3403,12 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(rename = "patch")] Patch, } - impl From<&HttpTriggerHttpMethod> for HttpTriggerHttpMethod { - fn from(value: &HttpTriggerHttpMethod) -> Self { + impl From<&HttpMethod> for HttpMethod { + fn from(value: &HttpMethod) -> Self { value.clone() } } - impl ToString for HttpTriggerHttpMethod { + impl ToString for HttpMethod { fn to_string(&self) -> String { match *self { Self::Get => "get".to_string(), @@ -2596,7 +3419,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } } - impl std::str::FromStr for HttpTriggerHttpMethod { + impl std::str::FromStr for HttpMethod { type Err = &'static str; fn from_str(value: &str) -> Result { match value { @@ -2609,25 +3432,55 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } } - impl std::convert::TryFrom<&str> for HttpTriggerHttpMethod { + impl std::convert::TryFrom<&str> for HttpMethod { type Error = &'static str; fn try_from(value: &str) -> Result { value.parse() } } - impl std::convert::TryFrom<&String> for HttpTriggerHttpMethod { + impl std::convert::TryFrom<&String> for HttpMethod { type Error = &'static str; fn try_from(value: &String) -> Result { value.parse() } } - impl std::convert::TryFrom for HttpTriggerHttpMethod { + impl std::convert::TryFrom for HttpMethod { type Error = &'static str; fn try_from(value: String) -> Result { value.parse() } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct HttpTrigger { + pub authentication_method: AuthenticationMethod, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub authentication_resource_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + pub http_method: HttpMethod, + pub is_async: bool, + pub is_static_website: bool, + pub raw_string: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + pub route_path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub static_asset_config: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub summary: Option, + pub workspaced_route: bool, + pub wrap_body: bool, + } + impl From<&HttpTrigger> for HttpTrigger { + fn from(value: &HttpTrigger) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct HttpTriggerStaticAssetConfig { #[serde(default, skip_serializing_if = "Option::is_none")] pub filename: Option, @@ -2640,27 +3493,71 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } - #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct HubScriptKind(pub serde_json::Value); - impl std::ops::Deref for HubScriptKind { - type Target = serde_json::Value; - fn deref(&self) -> &serde_json::Value { - &self.0 - } - } - impl From for serde_json::Value { - fn from(value: HubScriptKind) -> Self { - value.0 - } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum HubScriptKind { + #[serde(rename = "script")] + Script, + #[serde(rename = "failure")] + Failure, + #[serde(rename = "trigger")] + Trigger, + #[serde(rename = "approval")] + Approval, } impl From<&HubScriptKind> for HubScriptKind { fn from(value: &HubScriptKind) -> Self { value.clone() } } - impl From for HubScriptKind { - fn from(value: serde_json::Value) -> Self { - Self(value) + impl ToString for HubScriptKind { + fn to_string(&self) -> String { + match *self { + Self::Script => "script".to_string(), + Self::Failure => "failure".to_string(), + Self::Trigger => "trigger".to_string(), + Self::Approval => "approval".to_string(), + } + } + } + impl std::str::FromStr for HubScriptKind { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "script" => Ok(Self::Script), + "failure" => Ok(Self::Failure), + "trigger" => Ok(Self::Trigger), + "approval" => Ok(Self::Approval), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for HubScriptKind { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for HubScriptKind { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for HubScriptKind { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() } } #[derive(Clone, Debug, Deserialize, Serialize)] @@ -2780,6 +3677,21 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct InstanceGroupWithWorkspaces { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub emails: Vec, + pub name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub workspaces: Vec, + } + impl From<&InstanceGroupWithWorkspaces> for InstanceGroupWithWorkspaces { + fn from(value: &InstanceGroupWithWorkspaces) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct JavascriptTransform { pub expr: String, #[serde(rename = "type")] @@ -3013,11 +3925,17 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub enabled: bool, #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub group_id: String, pub kafka_resource_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, pub topics: Vec, } @@ -3085,6 +4003,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub azure_blob_resource_path: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub gcs_resource_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub public_resource: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub s3_resource_path: Option, @@ -3106,6 +4026,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub azure_blob_resource_path: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub gcs_resource_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub public_resource: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub s3_resource_path: Option, @@ -3135,6 +4057,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK AzureBlobStorage, AzureWorkloadIdentity, S3AwsOidc, + GoogleCloudStorage, } impl From<&LargeFileStorageSecondaryStorageValueType> for LargeFileStorageSecondaryStorageValueType { @@ -3149,6 +4072,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::AzureBlobStorage => "AzureBlobStorage".to_string(), Self::AzureWorkloadIdentity => "AzureWorkloadIdentity".to_string(), Self::S3AwsOidc => "S3AwsOidc".to_string(), + Self::GoogleCloudStorage => "GoogleCloudStorage".to_string(), } } } @@ -3160,6 +4084,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK "AzureBlobStorage" => Ok(Self::AzureBlobStorage), "AzureWorkloadIdentity" => Ok(Self::AzureWorkloadIdentity), "S3AwsOidc" => Ok(Self::S3AwsOidc), + "GoogleCloudStorage" => Ok(Self::GoogleCloudStorage), _ => Err("invalid value"), } } @@ -3199,6 +4124,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK AzureBlobStorage, AzureWorkloadIdentity, S3AwsOidc, + GoogleCloudStorage, } impl From<&LargeFileStorageType> for LargeFileStorageType { fn from(value: &LargeFileStorageType) -> Self { @@ -3212,6 +4138,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::AzureBlobStorage => "AzureBlobStorage".to_string(), Self::AzureWorkloadIdentity => "AzureWorkloadIdentity".to_string(), Self::S3AwsOidc => "S3AwsOidc".to_string(), + Self::GoogleCloudStorage => "GoogleCloudStorage".to_string(), } } } @@ -3223,6 +4150,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK "AzureBlobStorage" => Ok(Self::AzureBlobStorage), "AzureWorkloadIdentity" => Ok(Self::AzureWorkloadIdentity), "S3AwsOidc" => Ok(Self::S3AwsOidc), + "GoogleCloudStorage" => Ok(Self::GoogleCloudStorage), _ => Err("invalid value"), } } @@ -3253,6 +4181,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub id: i64, pub path: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub raw_app: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub starred: Option, pub summary: String, pub version: i64, @@ -3479,7 +4409,12 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(rename = "str")] Str(Option>), #[serde(rename = "object")] - Object(Vec), + Object { + #[serde(default, skip_serializing_if = "Option::is_none")] + name: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + props: Vec, + }, #[serde(rename = "list")] List(MainArgSignatureArgsItemTypList), } @@ -3498,12 +4433,6 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::Str(value) } } - impl From> - for MainArgSignatureArgsItemTyp { - fn from(value: Vec) -> Self { - Self::Object(value) - } - } impl From for MainArgSignatureArgsItemTyp { fn from(value: MainArgSignatureArgsItemTypList) -> Self { Self::List(value) @@ -3543,18 +4472,18 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub struct MainArgSignatureArgsItemTypObjectItem { + pub struct MainArgSignatureArgsItemTypObjectPropsItem { pub key: String, - pub typ: MainArgSignatureArgsItemTypObjectItemTyp, + pub typ: MainArgSignatureArgsItemTypObjectPropsItemTyp, } - impl From<&MainArgSignatureArgsItemTypObjectItem> - for MainArgSignatureArgsItemTypObjectItem { - fn from(value: &MainArgSignatureArgsItemTypObjectItem) -> Self { + impl From<&MainArgSignatureArgsItemTypObjectPropsItem> + for MainArgSignatureArgsItemTypObjectPropsItem { + fn from(value: &MainArgSignatureArgsItemTypObjectPropsItem) -> Self { value.clone() } } #[derive(Clone, Debug, Deserialize, Serialize)] - pub enum MainArgSignatureArgsItemTypObjectItemTyp { + pub enum MainArgSignatureArgsItemTypObjectPropsItemTyp { #[serde(rename = "float")] Float, #[serde(rename = "int")] @@ -3576,13 +4505,13 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(rename = "str")] Str(serde_json::Value), } - impl From<&MainArgSignatureArgsItemTypObjectItemTyp> - for MainArgSignatureArgsItemTypObjectItemTyp { - fn from(value: &MainArgSignatureArgsItemTypObjectItemTyp) -> Self { + impl From<&MainArgSignatureArgsItemTypObjectPropsItemTyp> + for MainArgSignatureArgsItemTypObjectPropsItemTyp { + fn from(value: &MainArgSignatureArgsItemTypObjectPropsItemTyp) -> Self { value.clone() } } - impl From for MainArgSignatureArgsItemTypObjectItemTyp { + impl From for MainArgSignatureArgsItemTypObjectPropsItemTyp { fn from(value: serde_json::Value) -> Self { Self::Str(value) } @@ -3807,9 +4736,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, pub mqtt_resource_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, pub subscribe_topics: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -3839,7 +4774,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub session_expiry_interval: Option, #[serde(default, skip_serializing_if = "Option::is_none")] - pub topic_alias: Option, + pub topic_alias_maximum: Option, } impl From<&MqttV5Config> for MqttV5Config { fn from(value: &MqttV5Config) -> Self { @@ -3854,9 +4789,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, pub nats_resource_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub stream_name: Option, @@ -3870,19 +4811,31 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewHttpTrigger { - pub http_method: NewHttpTriggerHttpMethod, + pub authentication_method: AuthenticationMethod, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub authentication_resource_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + pub http_method: HttpMethod, pub is_async: bool, pub is_flow: bool, pub is_static_website: bool, pub path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub raw_string: Option, - pub requires_auth: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub route_path: String, pub script_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub static_asset_config: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub workspaced_route: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub wrap_body: Option, @@ -3892,77 +4845,6 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } - #[derive( - Clone, - Copy, - Debug, - Deserialize, - Eq, - Hash, - Ord, - PartialEq, - PartialOrd, - Serialize - )] - pub enum NewHttpTriggerHttpMethod { - #[serde(rename = "get")] - Get, - #[serde(rename = "post")] - Post, - #[serde(rename = "put")] - Put, - #[serde(rename = "delete")] - Delete, - #[serde(rename = "patch")] - Patch, - } - impl From<&NewHttpTriggerHttpMethod> for NewHttpTriggerHttpMethod { - fn from(value: &NewHttpTriggerHttpMethod) -> Self { - value.clone() - } - } - impl ToString for NewHttpTriggerHttpMethod { - fn to_string(&self) -> String { - match *self { - Self::Get => "get".to_string(), - Self::Post => "post".to_string(), - Self::Put => "put".to_string(), - Self::Delete => "delete".to_string(), - Self::Patch => "patch".to_string(), - } - } - } - impl std::str::FromStr for NewHttpTriggerHttpMethod { - type Err = &'static str; - fn from_str(value: &str) -> Result { - match value { - "get" => Ok(Self::Get), - "post" => Ok(Self::Post), - "put" => Ok(Self::Put), - "delete" => Ok(Self::Delete), - "patch" => Ok(Self::Patch), - _ => Err("invalid value"), - } - } - } - impl std::convert::TryFrom<&str> for NewHttpTriggerHttpMethod { - type Error = &'static str; - fn try_from(value: &str) -> Result { - value.parse() - } - } - impl std::convert::TryFrom<&String> for NewHttpTriggerHttpMethod { - type Error = &'static str; - fn try_from(value: &String) -> Result { - value.parse() - } - } - impl std::convert::TryFrom for NewHttpTriggerHttpMethod { - type Error = &'static str; - fn try_from(value: String) -> Result { - value.parse() - } - } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewHttpTriggerStaticAssetConfig { #[serde(default, skip_serializing_if = "Option::is_none")] @@ -3980,10 +4862,16 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub struct NewKafkaTrigger { #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub group_id: String, pub is_flow: bool, pub kafka_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub topics: Vec, } @@ -4000,9 +4888,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub client_version: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub mqtt_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub subscribe_topics: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -4021,9 +4915,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub consumer_name: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub nats_resource_path: String, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub stream_name: Option, @@ -4038,6 +4938,10 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewPostgresTrigger { pub enabled: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, pub path: String, pub postgres_resource_path: String, @@ -4047,6 +4951,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub publication_name: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub replication_slot_name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, } impl From<&NewPostgresTrigger> for NewPostgresTrigger { @@ -4057,43 +4963,62 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewSchedule { pub args: ScriptArgs, + ///The version of the cron schedule to use (last is v2) #[serde(default, skip_serializing_if = "Option::is_none")] pub cron_version: Option, + ///The description of the schedule + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + ///Whether the schedule is enabled #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + ///Whether the schedule is for a flow pub is_flow: bool, + ///Whether the schedule should not run if a flow is already running #[serde(default, skip_serializing_if = "Option::is_none")] pub no_flow_overlap: Option, + ///The path to the script or flow to trigger on failure #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure: Option, + ///Whether the schedule should only run on the exact time #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_exact: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_extra_args: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_failure_times: Option, + ///The path to the script or flow to trigger on recovery #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery_extra_args: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_recovery_times: Option, + ///The path to the script or flow to trigger on success #[serde(default, skip_serializing_if = "Option::is_none")] pub on_success: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub on_success_extra_args: Option, + ///The path where the schedule will be created pub path: String, + ///The date and time the schedule will be paused until #[serde(default, skip_serializing_if = "Option::is_none")] pub paused_until: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] pub retry: Option, + ///The cron schedule to trigger the script or flow. Should include seconds. pub schedule: String, + ///The path to the script or flow to trigger pub script_path: String, + ///The summary of the schedule #[serde(default, skip_serializing_if = "Option::is_none")] pub summary: Option, + ///The tag of the schedule #[serde(default, skip_serializing_if = "Option::is_none")] pub tag: Option, + ///The timezone to use for the cron schedule pub timezone: String, + ///Whether the WebSocket error handler is muted #[serde(default, skip_serializing_if = "Option::is_none")] pub ws_error_handler_muted: Option, } @@ -4104,6 +5029,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewScript { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub assets: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] pub cache_ttl: Option, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -4163,6 +5090,146 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct NewScriptAssetsItem { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub access_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub alt_access_type: Option, + pub kind: AssetKind, + pub path: String, + } + impl From<&NewScriptAssetsItem> for NewScriptAssetsItem { + fn from(value: &NewScriptAssetsItem) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum NewScriptAssetsItemAccessType { + #[serde(rename = "r")] + R, + #[serde(rename = "w")] + W, + #[serde(rename = "rw")] + Rw, + } + impl From<&NewScriptAssetsItemAccessType> for NewScriptAssetsItemAccessType { + fn from(value: &NewScriptAssetsItemAccessType) -> Self { + value.clone() + } + } + impl ToString for NewScriptAssetsItemAccessType { + fn to_string(&self) -> String { + match *self { + Self::R => "r".to_string(), + Self::W => "w".to_string(), + Self::Rw => "rw".to_string(), + } + } + } + impl std::str::FromStr for NewScriptAssetsItemAccessType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "r" => Ok(Self::R), + "w" => Ok(Self::W), + "rw" => Ok(Self::Rw), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for NewScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for NewScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for NewScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum NewScriptAssetsItemAltAccessType { + #[serde(rename = "r")] + R, + #[serde(rename = "w")] + W, + #[serde(rename = "rw")] + Rw, + } + impl From<&NewScriptAssetsItemAltAccessType> for NewScriptAssetsItemAltAccessType { + fn from(value: &NewScriptAssetsItemAltAccessType) -> Self { + value.clone() + } + } + impl ToString for NewScriptAssetsItemAltAccessType { + fn to_string(&self) -> String { + match *self { + Self::R => "r".to_string(), + Self::W => "w".to_string(), + Self::Rw => "rw".to_string(), + } + } + } + impl std::str::FromStr for NewScriptAssetsItemAltAccessType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "r" => Ok(Self::R), + "w" => Ok(Self::W), + "rw" => Ok(Self::Rw), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for NewScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for NewScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for NewScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } #[derive( Clone, Copy, @@ -4253,14 +5320,21 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct NewSqsTrigger { + pub aws_auth_resource_type: AwsAuthResourceType, pub aws_resource_path: String, #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub is_flow: bool, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub message_attributes: Vec, pub path: String, pub queue_url: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, } impl From<&NewSqsTrigger> for NewSqsTrigger { @@ -4304,11 +5378,17 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub can_return_message: bool, #[serde(default, skip_serializing_if = "Option::is_none")] pub enabled: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub filters: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub initial_messages: Vec, pub is_flow: bool, pub path: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, pub script_path: String, pub url: String, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -4383,6 +5463,121 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct OpenapiHttpRouteFilters { + pub folder_regex: String, + pub path_regex: String, + pub route_path_regex: String, + } + impl From<&OpenapiHttpRouteFilters> for OpenapiHttpRouteFilters { + fn from(value: &OpenapiHttpRouteFilters) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum OpenapiSpecFormat { + #[serde(rename = "yaml")] + Yaml, + #[serde(rename = "json")] + Json, + } + impl From<&OpenapiSpecFormat> for OpenapiSpecFormat { + fn from(value: &OpenapiSpecFormat) -> Self { + value.clone() + } + } + impl ToString for OpenapiSpecFormat { + fn to_string(&self) -> String { + match *self { + Self::Yaml => "yaml".to_string(), + Self::Json => "json".to_string(), + } + } + } + impl std::str::FromStr for OpenapiSpecFormat { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "yaml" => Ok(Self::Yaml), + "json" => Ok(Self::Json), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for OpenapiSpecFormat { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for OpenapiSpecFormat { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for OpenapiSpecFormat { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct OpenapiV3Info { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub contact: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub license: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub terms_of_service: Option, + pub title: String, + pub version: String, + } + impl From<&OpenapiV3Info> for OpenapiV3Info { + fn from(value: &OpenapiV3Info) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct OpenapiV3InfoContact { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub email: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub url: Option, + } + impl From<&OpenapiV3InfoContact> for OpenapiV3InfoContact { + fn from(value: &OpenapiV3InfoContact) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct OpenapiV3InfoLicense { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub identifier: Option, + pub name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub url: Option, + } + impl From<&OpenapiV3InfoLicense> for OpenapiV3InfoLicense { + fn from(value: &OpenapiV3InfoLicense) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct OperatorSettings(pub Option); impl std::ops::Deref for OperatorSettings { type Target = Option; @@ -4407,6 +5602,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct OperatorSettingsInner { + ///Whether operators can view assets + pub assets: bool, ///Whether operators can view audit logs pub audit_logs: bool, ///Whether operators can view folders page @@ -4689,11 +5886,17 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, pub postgres_resource_path: String, pub publication_name: String, pub replication_slot_name: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, } impl From<&PostgresTrigger> for PostgresTrigger { @@ -4717,6 +5920,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub path: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub script_hash: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub tag: Option, } impl From<&Preview> for Preview { @@ -4799,6 +6004,17 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct PushConfig { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub audience: Option, + pub authenticate: bool, + } + impl From<&PushConfig> for PushConfig { + fn from(value: &PushConfig) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct QueuedJob { #[serde(default, skip_serializing_if = "Option::is_none")] pub aggregate_wait_time_ms: Option, @@ -4861,6 +6077,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub worker: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub workflow_as_code_status: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub workspace_id: Option, } impl From<&QueuedJob> for QueuedJob { @@ -4977,6 +6195,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct RawScript { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub assets: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] pub concurrency_time_window_s: Option, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -5003,6 +6223,209 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct RawScriptAssetsItem { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub access_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub alt_access_type: Option, + pub kind: RawScriptAssetsItemKind, + pub path: String, + } + impl From<&RawScriptAssetsItem> for RawScriptAssetsItem { + fn from(value: &RawScriptAssetsItem) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum RawScriptAssetsItemAccessType { + #[serde(rename = "r")] + R, + #[serde(rename = "w")] + W, + #[serde(rename = "rw")] + Rw, + } + impl From<&RawScriptAssetsItemAccessType> for RawScriptAssetsItemAccessType { + fn from(value: &RawScriptAssetsItemAccessType) -> Self { + value.clone() + } + } + impl ToString for RawScriptAssetsItemAccessType { + fn to_string(&self) -> String { + match *self { + Self::R => "r".to_string(), + Self::W => "w".to_string(), + Self::Rw => "rw".to_string(), + } + } + } + impl std::str::FromStr for RawScriptAssetsItemAccessType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "r" => Ok(Self::R), + "w" => Ok(Self::W), + "rw" => Ok(Self::Rw), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for RawScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for RawScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for RawScriptAssetsItemAccessType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum RawScriptAssetsItemAltAccessType { + #[serde(rename = "r")] + R, + #[serde(rename = "w")] + W, + #[serde(rename = "rw")] + Rw, + } + impl From<&RawScriptAssetsItemAltAccessType> for RawScriptAssetsItemAltAccessType { + fn from(value: &RawScriptAssetsItemAltAccessType) -> Self { + value.clone() + } + } + impl ToString for RawScriptAssetsItemAltAccessType { + fn to_string(&self) -> String { + match *self { + Self::R => "r".to_string(), + Self::W => "w".to_string(), + Self::Rw => "rw".to_string(), + } + } + } + impl std::str::FromStr for RawScriptAssetsItemAltAccessType { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "r" => Ok(Self::R), + "w" => Ok(Self::W), + "rw" => Ok(Self::Rw), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for RawScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for RawScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for RawScriptAssetsItemAltAccessType { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum RawScriptAssetsItemKind { + #[serde(rename = "s3object")] + S3object, + #[serde(rename = "resource")] + Resource, + #[serde(rename = "ducklake")] + Ducklake, + } + impl From<&RawScriptAssetsItemKind> for RawScriptAssetsItemKind { + fn from(value: &RawScriptAssetsItemKind) -> Self { + value.clone() + } + } + impl ToString for RawScriptAssetsItemKind { + fn to_string(&self) -> String { + match *self { + Self::S3object => "s3object".to_string(), + Self::Resource => "resource".to_string(), + Self::Ducklake => "ducklake".to_string(), + } + } + } + impl std::str::FromStr for RawScriptAssetsItemKind { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "s3object" => Ok(Self::S3object), + "resource" => Ok(Self::Resource), + "ducklake" => Ok(Self::Ducklake), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for RawScriptAssetsItemKind { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for RawScriptAssetsItemKind { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for RawScriptAssetsItemKind { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct RawScriptForDependencies { pub language: ScriptLang, pub path: String, @@ -5299,6 +6722,65 @@ the execution of this script will be permissioned_as and by extension its DT_TOK PartialOrd, Serialize )] + pub enum RunnableKind { + #[serde(rename = "script")] + Script, + #[serde(rename = "flow")] + Flow, + } + impl From<&RunnableKind> for RunnableKind { + fn from(value: &RunnableKind) -> Self { + value.clone() + } + } + impl ToString for RunnableKind { + fn to_string(&self) -> String { + match *self { + Self::Script => "script".to_string(), + Self::Flow => "flow".to_string(), + } + } + } + impl std::str::FromStr for RunnableKind { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "script" => Ok(Self::Script), + "flow" => Ok(Self::Flow), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for RunnableKind { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for RunnableKind { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for RunnableKind { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] pub enum RunnableType { ScriptHash, ScriptPath, @@ -5348,6 +6830,21 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct S3Object { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub presigned: Option, + pub s3: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub storage: Option, + } + impl From<&S3Object> for S3Object { + fn from(value: &S3Object) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct S3Resource { #[serde(rename = "accessKey", default, skip_serializing_if = "Option::is_none")] pub access_key: Option, @@ -5384,6 +6881,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub args: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub cron_version: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, pub edited_at: chrono::DateTime, pub edited_by: String, pub email: String, @@ -5422,8 +6921,6 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub summary: Option, #[serde(default, skip_serializing_if = "Option::is_none")] - pub description: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] pub tag: Option, pub timezone: String, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -5458,6 +6955,31 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct ScopeDefinition { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + pub label: String, + pub requires_resource_path: bool, + pub value: String, + } + impl From<&ScopeDefinition> for ScopeDefinition { + fn from(value: &ScopeDefinition) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct ScopeDomain { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, + pub name: String, + pub scopes: Vec, + } + impl From<&ScopeDomain> for ScopeDomain { + fn from(value: &ScopeDomain) -> Self { + value.clone() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct Script { pub archived: bool, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -5687,6 +7209,12 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Csharp, #[serde(rename = "nu")] Nu, + #[serde(rename = "java")] + Java, + #[serde(rename = "ruby")] + Ruby, + #[serde(rename = "duckdb")] + Duckdb, } impl From<&ScriptLang> for ScriptLang { fn from(value: &ScriptLang) -> Self { @@ -5715,6 +7243,9 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Self::Ansible => "ansible".to_string(), Self::Csharp => "csharp".to_string(), Self::Nu => "nu".to_string(), + Self::Java => "java".to_string(), + Self::Ruby => "ruby".to_string(), + Self::Duckdb => "duckdb".to_string(), } } } @@ -5741,6 +7272,9 @@ the execution of this script will be permissioned_as and by extension its DT_TOK "ansible" => Ok(Self::Ansible), "csharp" => Ok(Self::Csharp), "nu" => Ok(Self::Nu), + "java" => Ok(Self::Java), + "ruby" => Ok(Self::Ruby), + "duckdb" => Ok(Self::Duckdb), _ => Err("invalid value"), } } @@ -5809,16 +7343,23 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct SqsTrigger { + pub aws_auth_resource_type: AwsAuthResourceType, pub aws_resource_path: String, pub enabled: bool, #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub message_attributes: Vec, pub queue_url: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, } impl From<&SqsTrigger> for SqsTrigger { @@ -5830,8 +7371,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK pub struct StaticTransform { #[serde(rename = "type")] pub type_: StaticTransformType, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub value: Option, + pub value: serde_json::Value, } impl From<&StaticTransform> for StaticTransform { fn from(value: &StaticTransform) -> Self { @@ -5851,8 +7391,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Serialize )] pub enum StaticTransformType { - #[serde(rename = "javascript")] - Javascript, + #[serde(rename = "static")] + Static, } impl From<&StaticTransformType> for StaticTransformType { fn from(value: &StaticTransformType) -> Self { @@ -5862,7 +7402,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK impl ToString for StaticTransformType { fn to_string(&self) -> String { match *self { - Self::Javascript => "javascript".to_string(), + Self::Static => "static".to_string(), } } } @@ -5870,7 +7410,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK type Err = &'static str; fn from_str(value: &str) -> Result { match value { - "javascript" => Ok(Self::Javascript), + "static" => Ok(Self::Static), _ => Err("invalid value"), } } @@ -5894,6 +7434,79 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct StopAfterIf { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_message: Option, + pub expr: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub skip_if_stopped: Option, + } + impl From<&StopAfterIf> for StopAfterIf { + fn from(value: &StopAfterIf) -> Self { + value.clone() + } + } + ///The mode of subscription. 'existing' means using an existing GCP subscription, while 'create_update' involves creating or updating a new subscription. + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum SubscriptionMode { + #[serde(rename = "existing")] + Existing, + #[serde(rename = "create_update")] + CreateUpdate, + } + impl From<&SubscriptionMode> for SubscriptionMode { + fn from(value: &SubscriptionMode) -> Self { + value.clone() + } + } + impl ToString for SubscriptionMode { + fn to_string(&self) -> String { + match *self { + Self::Existing => "existing".to_string(), + Self::CreateUpdate => "create_update".to_string(), + } + } + } + impl std::str::FromStr for SubscriptionMode { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "existing" => Ok(Self::Existing), + "create_update" => Ok(Self::CreateUpdate), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for SubscriptionMode { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for SubscriptionMode { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for SubscriptionMode { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct TableToTrack(pub Vec); impl std::ops::Deref for TableToTrack { type Target = Vec; @@ -5944,6 +7557,254 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct TeamsChannel { + ///Microsoft Teams channel ID + pub channel_id: TeamsChannelChannelId, + ///Microsoft Teams channel name + pub channel_name: TeamsChannelChannelName, + ///Microsoft Teams team ID + pub team_id: TeamsChannelTeamId, + ///Microsoft Teams team name + pub team_name: TeamsChannelTeamName, + } + impl From<&TeamsChannel> for TeamsChannel { + fn from(value: &TeamsChannel) -> Self { + value.clone() + } + } + ///Microsoft Teams channel ID + #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)] + pub struct TeamsChannelChannelId(String); + impl std::ops::Deref for TeamsChannelChannelId { + type Target = String; + fn deref(&self) -> &String { + &self.0 + } + } + impl From for String { + fn from(value: TeamsChannelChannelId) -> Self { + value.0 + } + } + impl From<&TeamsChannelChannelId> for TeamsChannelChannelId { + fn from(value: &TeamsChannelChannelId) -> Self { + value.clone() + } + } + impl std::str::FromStr for TeamsChannelChannelId { + type Err = &'static str; + fn from_str(value: &str) -> Result { + if value.len() < 1usize { + return Err("shorter than 1 characters"); + } + Ok(Self(value.to_string())) + } + } + impl std::convert::TryFrom<&str> for TeamsChannelChannelId { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for TeamsChannelChannelId { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for TeamsChannelChannelId { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + impl<'de> serde::Deserialize<'de> for TeamsChannelChannelId { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + String::deserialize(deserializer)? + .parse() + .map_err(|e: &'static str| { + ::custom(e.to_string()) + }) + } + } + ///Microsoft Teams channel name + #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)] + pub struct TeamsChannelChannelName(String); + impl std::ops::Deref for TeamsChannelChannelName { + type Target = String; + fn deref(&self) -> &String { + &self.0 + } + } + impl From for String { + fn from(value: TeamsChannelChannelName) -> Self { + value.0 + } + } + impl From<&TeamsChannelChannelName> for TeamsChannelChannelName { + fn from(value: &TeamsChannelChannelName) -> Self { + value.clone() + } + } + impl std::str::FromStr for TeamsChannelChannelName { + type Err = &'static str; + fn from_str(value: &str) -> Result { + if value.len() < 1usize { + return Err("shorter than 1 characters"); + } + Ok(Self(value.to_string())) + } + } + impl std::convert::TryFrom<&str> for TeamsChannelChannelName { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for TeamsChannelChannelName { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for TeamsChannelChannelName { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + impl<'de> serde::Deserialize<'de> for TeamsChannelChannelName { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + String::deserialize(deserializer)? + .parse() + .map_err(|e: &'static str| { + ::custom(e.to_string()) + }) + } + } + ///Microsoft Teams team ID + #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)] + pub struct TeamsChannelTeamId(String); + impl std::ops::Deref for TeamsChannelTeamId { + type Target = String; + fn deref(&self) -> &String { + &self.0 + } + } + impl From for String { + fn from(value: TeamsChannelTeamId) -> Self { + value.0 + } + } + impl From<&TeamsChannelTeamId> for TeamsChannelTeamId { + fn from(value: &TeamsChannelTeamId) -> Self { + value.clone() + } + } + impl std::str::FromStr for TeamsChannelTeamId { + type Err = &'static str; + fn from_str(value: &str) -> Result { + if value.len() < 1usize { + return Err("shorter than 1 characters"); + } + Ok(Self(value.to_string())) + } + } + impl std::convert::TryFrom<&str> for TeamsChannelTeamId { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for TeamsChannelTeamId { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for TeamsChannelTeamId { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + impl<'de> serde::Deserialize<'de> for TeamsChannelTeamId { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + String::deserialize(deserializer)? + .parse() + .map_err(|e: &'static str| { + ::custom(e.to_string()) + }) + } + } + ///Microsoft Teams team name + #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)] + pub struct TeamsChannelTeamName(String); + impl std::ops::Deref for TeamsChannelTeamName { + type Target = String; + fn deref(&self) -> &String { + &self.0 + } + } + impl From for String { + fn from(value: TeamsChannelTeamName) -> Self { + value.0 + } + } + impl From<&TeamsChannelTeamName> for TeamsChannelTeamName { + fn from(value: &TeamsChannelTeamName) -> Self { + value.clone() + } + } + impl std::str::FromStr for TeamsChannelTeamName { + type Err = &'static str; + fn from_str(value: &str) -> Result { + if value.len() < 1usize { + return Err("shorter than 1 characters"); + } + Ok(Self(value.to_string())) + } + } + impl std::convert::TryFrom<&str> for TeamsChannelTeamName { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for TeamsChannelTeamName { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for TeamsChannelTeamName { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + impl<'de> serde::Deserialize<'de> for TeamsChannelTeamName { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + String::deserialize(deserializer)? + .parse() + .map_err(|e: &'static str| { + ::custom(e.to_string()) + }) + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct TemplateScript { pub language: Language, pub postgres_resource_path: String, @@ -5971,6 +7832,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub expires_in: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub grant_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub refresh_token: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub scope: Vec, @@ -6001,6 +7864,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Option::is_none")] pub email_count: Option, #[serde(default, skip_serializing_if = "Option::is_none")] + pub gcp_count: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub http_routes_count: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub kafka_count: Option, @@ -6078,6 +7943,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct User { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub added_via: Option, pub created_at: chrono::DateTime, pub disabled: bool, pub email: String, @@ -6098,6 +7965,86 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct UserSource { + ///The domain used for auto-invite (when source is 'domain') + #[serde(default, skip_serializing_if = "Option::is_none")] + pub domain: Option, + ///The instance group name (when source is 'instance_group') + #[serde(default, skip_serializing_if = "Option::is_none")] + pub group: Option, + ///How the user was added to the workspace + pub source: UserSourceSource, + } + impl From<&UserSource> for UserSource { + fn from(value: &UserSource) -> Self { + value.clone() + } + } + ///How the user was added to the workspace + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum UserSourceSource { + #[serde(rename = "domain")] + Domain, + #[serde(rename = "instance_group")] + InstanceGroup, + #[serde(rename = "manual")] + Manual, + } + impl From<&UserSourceSource> for UserSourceSource { + fn from(value: &UserSourceSource) -> Self { + value.clone() + } + } + impl ToString for UserSourceSource { + fn to_string(&self) -> String { + match *self { + Self::Domain => "domain".to_string(), + Self::InstanceGroup => "instance_group".to_string(), + Self::Manual => "manual".to_string(), + } + } + } + impl std::str::FromStr for UserSourceSource { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "domain" => Ok(Self::Domain), + "instance_group" => Ok(Self::InstanceGroup), + "manual" => Ok(Self::Manual), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for UserSourceSource { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for UserSourceSource { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for UserSourceSource { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct UserUsage { #[serde(default, skip_serializing_if = "Option::is_none")] pub email: Option, @@ -6134,17 +8081,98 @@ the execution of this script will be permissioned_as and by extension its DT_TOK } } #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct WebhookFilters { + pub path: String, + pub runnable_kind: RunnableKind, + pub user_or_folder_regex: WebhookFiltersUserOrFolderRegex, + pub user_or_folder_regex_value: String, + } + impl From<&WebhookFilters> for WebhookFilters { + fn from(value: &WebhookFilters) -> Self { + value.clone() + } + } + #[derive( + Clone, + Copy, + Debug, + Deserialize, + Eq, + Hash, + Ord, + PartialEq, + PartialOrd, + Serialize + )] + pub enum WebhookFiltersUserOrFolderRegex { + #[serde(rename = "*")] + X, + #[serde(rename = "u")] + U, + #[serde(rename = "f")] + F, + } + impl From<&WebhookFiltersUserOrFolderRegex> for WebhookFiltersUserOrFolderRegex { + fn from(value: &WebhookFiltersUserOrFolderRegex) -> Self { + value.clone() + } + } + impl ToString for WebhookFiltersUserOrFolderRegex { + fn to_string(&self) -> String { + match *self { + Self::X => "*".to_string(), + Self::U => "u".to_string(), + Self::F => "f".to_string(), + } + } + } + impl std::str::FromStr for WebhookFiltersUserOrFolderRegex { + type Err = &'static str; + fn from_str(value: &str) -> Result { + match value { + "*" => Ok(Self::X), + "u" => Ok(Self::U), + "f" => Ok(Self::F), + _ => Err("invalid value"), + } + } + } + impl std::convert::TryFrom<&str> for WebhookFiltersUserOrFolderRegex { + type Error = &'static str; + fn try_from(value: &str) -> Result { + value.parse() + } + } + impl std::convert::TryFrom<&String> for WebhookFiltersUserOrFolderRegex { + type Error = &'static str; + fn try_from(value: &String) -> Result { + value.parse() + } + } + impl std::convert::TryFrom for WebhookFiltersUserOrFolderRegex { + type Error = &'static str; + fn try_from(value: String) -> Result { + value.parse() + } + } + #[derive(Clone, Debug, Deserialize, Serialize)] pub struct WebsocketTrigger { pub can_return_message: bool, pub enabled: bool, #[serde(default, skip_serializing_if = "Option::is_none")] pub error: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_args: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error_handler_path: Option, pub filters: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub initial_messages: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] pub last_server_ping: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] + pub retry: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub server_id: Option, pub url: String, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -6206,8 +8234,8 @@ the execution of this script will be permissioned_as and by extension its DT_TOK Serialize )] pub enum WhileloopFlowType { - #[serde(rename = "forloopflow")] - Forloopflow, + #[serde(rename = "whileloopflow")] + Whileloopflow, } impl From<&WhileloopFlowType> for WhileloopFlowType { fn from(value: &WhileloopFlowType) -> Self { @@ -6217,7 +8245,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK impl ToString for WhileloopFlowType { fn to_string(&self) -> String { match *self { - Self::Forloopflow => "forloopflow".to_string(), + Self::Whileloopflow => "whileloopflow".to_string(), } } } @@ -6225,7 +8253,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK type Err = &'static str; fn from_str(value: &str) -> Result { match value { - "forloopflow" => Ok(Self::Forloopflow), + "whileloopflow" => Ok(Self::Whileloopflow), _ => Err("invalid value"), } } @@ -6476,99 +8504,15 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[serde(default, skip_serializing_if = "Vec::is_empty")] pub include_path: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub include_type: Vec, + pub include_type: Vec, } impl From<&WorkspaceDeployUiSettings> for WorkspaceDeployUiSettings { fn from(value: &WorkspaceDeployUiSettings) -> Self { value.clone() } } - #[derive( - Clone, - Copy, - Debug, - Deserialize, - Eq, - Hash, - Ord, - PartialEq, - PartialOrd, - Serialize - )] - pub enum WorkspaceDeployUiSettingsIncludeTypeItem { - #[serde(rename = "script")] - Script, - #[serde(rename = "flow")] - Flow, - #[serde(rename = "app")] - App, - #[serde(rename = "resource")] - Resource, - #[serde(rename = "variable")] - Variable, - #[serde(rename = "secret")] - Secret, - #[serde(rename = "trigger")] - Trigger, - } - impl From<&WorkspaceDeployUiSettingsIncludeTypeItem> - for WorkspaceDeployUiSettingsIncludeTypeItem { - fn from(value: &WorkspaceDeployUiSettingsIncludeTypeItem) -> Self { - value.clone() - } - } - impl ToString for WorkspaceDeployUiSettingsIncludeTypeItem { - fn to_string(&self) -> String { - match *self { - Self::Script => "script".to_string(), - Self::Flow => "flow".to_string(), - Self::App => "app".to_string(), - Self::Resource => "resource".to_string(), - Self::Variable => "variable".to_string(), - Self::Secret => "secret".to_string(), - Self::Trigger => "trigger".to_string(), - } - } - } - impl std::str::FromStr for WorkspaceDeployUiSettingsIncludeTypeItem { - type Err = &'static str; - fn from_str(value: &str) -> Result { - match value { - "script" => Ok(Self::Script), - "flow" => Ok(Self::Flow), - "app" => Ok(Self::App), - "resource" => Ok(Self::Resource), - "variable" => Ok(Self::Variable), - "secret" => Ok(Self::Secret), - "trigger" => Ok(Self::Trigger), - _ => Err("invalid value"), - } - } - } - impl std::convert::TryFrom<&str> for WorkspaceDeployUiSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: &str) -> Result { - value.parse() - } - } - impl std::convert::TryFrom<&String> for WorkspaceDeployUiSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: &String) -> Result { - value.parse() - } - } - impl std::convert::TryFrom for WorkspaceDeployUiSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: String) -> Result { - value.parse() - } - } #[derive(Clone, Debug, Deserialize, Serialize)] pub struct WorkspaceGitSyncSettings { - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub include_path: Vec, - #[serde(default, skip_serializing_if = "Vec::is_empty")] - pub include_type: Vec, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub repositories: Vec, } @@ -6577,100 +8521,28 @@ the execution of this script will be permissioned_as and by extension its DT_TOK value.clone() } } - #[derive( - Clone, - Copy, - Debug, - Deserialize, - Eq, - Hash, - Ord, - PartialEq, - PartialOrd, - Serialize - )] - pub enum WorkspaceGitSyncSettingsIncludeTypeItem { - #[serde(rename = "script")] - Script, - #[serde(rename = "flow")] - Flow, - #[serde(rename = "app")] - App, - #[serde(rename = "folder")] - Folder, - #[serde(rename = "resource")] - Resource, - #[serde(rename = "variable")] - Variable, - #[serde(rename = "secret")] - Secret, - #[serde(rename = "resourcetype")] - Resourcetype, - #[serde(rename = "schedule")] - Schedule, - #[serde(rename = "user")] - User, - #[serde(rename = "group")] - Group, + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct WorkspaceGithubInstallation { + pub account_id: String, + pub installation_id: f64, } - impl From<&WorkspaceGitSyncSettingsIncludeTypeItem> - for WorkspaceGitSyncSettingsIncludeTypeItem { - fn from(value: &WorkspaceGitSyncSettingsIncludeTypeItem) -> Self { + impl From<&WorkspaceGithubInstallation> for WorkspaceGithubInstallation { + fn from(value: &WorkspaceGithubInstallation) -> Self { value.clone() } } - impl ToString for WorkspaceGitSyncSettingsIncludeTypeItem { - fn to_string(&self) -> String { - match *self { - Self::Script => "script".to_string(), - Self::Flow => "flow".to_string(), - Self::App => "app".to_string(), - Self::Folder => "folder".to_string(), - Self::Resource => "resource".to_string(), - Self::Variable => "variable".to_string(), - Self::Secret => "secret".to_string(), - Self::Resourcetype => "resourcetype".to_string(), - Self::Schedule => "schedule".to_string(), - Self::User => "user".to_string(), - Self::Group => "group".to_string(), - } - } + #[derive(Clone, Debug, Deserialize, Serialize)] + pub struct WorkspaceInfo { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub role: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub workspace_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub workspace_name: Option, } - impl std::str::FromStr for WorkspaceGitSyncSettingsIncludeTypeItem { - type Err = &'static str; - fn from_str(value: &str) -> Result { - match value { - "script" => Ok(Self::Script), - "flow" => Ok(Self::Flow), - "app" => Ok(Self::App), - "folder" => Ok(Self::Folder), - "resource" => Ok(Self::Resource), - "variable" => Ok(Self::Variable), - "secret" => Ok(Self::Secret), - "resourcetype" => Ok(Self::Resourcetype), - "schedule" => Ok(Self::Schedule), - "user" => Ok(Self::User), - "group" => Ok(Self::Group), - _ => Err("invalid value"), - } - } - } - impl std::convert::TryFrom<&str> for WorkspaceGitSyncSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: &str) -> Result { - value.parse() - } - } - impl std::convert::TryFrom<&String> for WorkspaceGitSyncSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: &String) -> Result { - value.parse() - } - } - impl std::convert::TryFrom for WorkspaceGitSyncSettingsIncludeTypeItem { - type Error = &'static str; - fn try_from(value: String) -> Result { - value.parse() + impl From<&WorkspaceInfo> for WorkspaceInfo { + fn from(value: &WorkspaceInfo) -> Self { + value.clone() } } #[derive(Clone, Debug, Deserialize, Serialize)] @@ -6689,7 +8561,7 @@ the execution of this script will be permissioned_as and by extension its DT_TOK #[derive(Clone, Debug)] /**Client for Windmill API -Version: 1.478.1*/ +Version: 1.526.1*/ pub struct Client { pub(crate) baseurl: String, pub(crate) client: reqwest::Client, @@ -6735,7 +8607,7 @@ impl Client { /// This string is pulled directly from the source OpenAPI /// document and may be in any format the API selects. pub fn api_version(&self) -> &'static str { - "1.478.1" + "1.526.1" } } impl Client { diff --git a/backend/windmill-api/openapi.yaml b/backend/windmill-api/openapi.yaml index 7b916c85d1..132fd8bd50 100644 --- a/backend/windmill-api/openapi.yaml +++ b/backend/windmill-api/openapi.yaml @@ -15128,7 +15128,8 @@ components: csharp, nu, java, - duckdb, + ruby, + duckdb # for related places search: ADD_NEW_LANG ] diff --git a/backend/windmill-api/src/scripts.rs b/backend/windmill-api/src/scripts.rs index d47b1b2c12..ca2cec7ce1 100644 --- a/backend/windmill-api/src/scripts.rs +++ b/backend/windmill-api/src/scripts.rs @@ -734,6 +734,7 @@ async fn create_script_internal<'c>( || ns.language == ScriptLang::Nu || ns.language == ScriptLang::Php || ns.language == ScriptLang::Java + || ns.language == ScriptLang::Ruby // for related places search: ADD_NEW_LANG ) { Some(String::new()) diff --git a/backend/windmill-api/src/workspaces_export.rs b/backend/windmill-api/src/workspaces_export.rs index c752367339..1b1f107be6 100644 --- a/backend/windmill-api/src/workspaces_export.rs +++ b/backend/windmill-api/src/workspaces_export.rs @@ -377,6 +377,7 @@ pub(crate) async fn tarball_workspace( ScriptLang::Nu => "nu", ScriptLang::OracleDB => "odb.sql", ScriptLang::Java => "java", + ScriptLang::Ruby => "rb", // for related places search: ADD_NEW_LANG }; archive diff --git a/backend/windmill-common/src/error.rs b/backend/windmill-common/src/error.rs index 6418968d28..97eb6fbced 100644 --- a/backend/windmill-common/src/error.rs +++ b/backend/windmill-common/src/error.rs @@ -181,6 +181,13 @@ impl From for Error { } } +impl From for Error { + #[track_caller] + fn from(e: url::ParseError) -> Self { + Self::ArgumentErr(format!("Cannot parse provided url. \ne: {e}")) + } +} + impl Error { /// https://docs.rs/anyhow/1/anyhow/struct.Error.html#display-representations pub fn alt(&self) -> String { diff --git a/backend/windmill-common/src/global_settings.rs b/backend/windmill-common/src/global_settings.rs index 6be5acca3a..c26bdc2f7e 100644 --- a/backend/windmill-common/src/global_settings.rs +++ b/backend/windmill-common/src/global_settings.rs @@ -13,6 +13,7 @@ pub const BUNFIG_INSTALL_SCOPES_SETTING: &str = "bunfig_install_scopes"; pub const NUGET_CONFIG_SETTING: &str = "nuget_config"; pub const MAVEN_REPOS_SETTING: &str = "maven_repos"; pub const NO_DEFAULT_MAVEN_SETTING: &str = "no_default_maven"; +pub const RUBY_REPOS_SETTING: &str = "ruby_repos"; pub const EXTRA_PIP_INDEX_URL_SETTING: &str = "pip_extra_index_url"; pub const PIP_INDEX_URL_SETTING: &str = "pip_index_url"; @@ -66,6 +67,10 @@ pub const ENV_SETTINGS: &[&str] = &[ "DENO_PATH", "GO_PATH", "JAVA_PATH", + "RUBY_PATH", + "BUNDLE_PATH", + "GEM_PATH", + "RUBY_CONCURRENT_DOWNLOADS", // for related places search: ADD_NEW_LANG "GOPRIVATE", "GOPROXY", diff --git a/backend/windmill-common/src/schema.rs b/backend/windmill-common/src/schema.rs index 71ecd220d1..d16b86d507 100644 --- a/backend/windmill-common/src/schema.rs +++ b/backend/windmill-common/src/schema.rs @@ -348,7 +348,7 @@ pub fn should_validate_schema(code: &str, lang: &ScriptLang) -> bool { use ScriptLang::*; let comment = match lang { Nativets | Bun | Bunnative | Deno | Php | CSharp | Java => "//", - Python3 | Go | Bash | Powershell | Graphql | Ansible | Nu => "#", + Python3 | Go | Bash | Powershell | Graphql | Ansible | Nu | Ruby => "#", Postgresql | Mysql | Bigquery | Snowflake | Mssql | OracleDB | DuckDb => "--", Rust => "//!", // for related places search: ADD_NEW_LANG diff --git a/backend/windmill-common/src/scripts.rs b/backend/windmill-common/src/scripts.rs index ff2f1865af..7633e60e25 100644 --- a/backend/windmill-common/src/scripts.rs +++ b/backend/windmill-common/src/scripts.rs @@ -55,7 +55,9 @@ pub enum ScriptLang { Ansible, CSharp, Nu, - Java, // for related places search: ADD_NEW_LANG + Java, + Ruby, + // for related places search: ADD_NEW_LANG } impl ScriptLang { @@ -83,6 +85,7 @@ impl ScriptLang { ScriptLang::CSharp => "csharp", ScriptLang::Nu => "nu", ScriptLang::Java => "java", + ScriptLang::Ruby => "ruby", // for related places search: ADD_NEW_LANG } } @@ -113,6 +116,8 @@ impl FromStr for ScriptLang { "csharp" => ScriptLang::CSharp, "nu" => ScriptLang::Nu, "java" => ScriptLang::Java, + "ruby" => ScriptLang::Ruby, + // for related places search: ADD_NEW_LANG language => { return Err(anyhow::anyhow!("{} is currently not supported", language).into()) } diff --git a/backend/windmill-common/src/worker.rs b/backend/windmill-common/src/worker.rs index c34b9959f1..50ed13ff7b 100644 --- a/backend/windmill-common/src/worker.rs +++ b/backend/windmill-common/src/worker.rs @@ -179,6 +179,7 @@ lazy_static::lazy_static! { "csharp".to_string(), "nu".to_string(), "java".to_string(), + "ruby".to_string(), "duckdb".to_string(), // for related places search: ADD_NEW_LANG "dependency".to_string(), @@ -622,6 +623,12 @@ fn parse_file(path: &str) -> Option { .flatten() } +#[derive(Copy, Clone)] +#[annotations("#")] +pub struct RubyAnnotations { + pub verbose: bool, +} + #[derive(Copy, Clone)] #[annotations("#")] pub struct PythonAnnotations { diff --git a/backend/windmill-worker/Cargo.toml b/backend/windmill-worker/Cargo.toml index d78d7cff27..3805171024 100644 --- a/backend/windmill-worker/Cargo.toml +++ b/backend/windmill-worker/Cargo.toml @@ -32,6 +32,7 @@ csharp = ["dep:windmill-parser-csharp"] rust = ["dep:windmill-parser-rust"] nu = ["dep:windmill-parser-nu"] java = ["dep:windmill-parser-java"] +ruby = ["dep:windmill-parser-ruby"] duckdb = ["dep:duckdb"] [dependencies] @@ -46,6 +47,7 @@ windmill-parser-rust = { workspace = true, optional = true } windmill-parser-csharp = { workspace = true, optional = true } windmill-parser-nu = { workspace = true, optional = true } windmill-parser-java = { workspace = true, optional = true } +windmill-parser-ruby = { workspace = true, optional = true } windmill-parser-py = { workspace = true, optional = true } windmill-parser-yaml.workspace = true windmill-parser-py-imports = { workspace = true, optional = true } diff --git a/backend/windmill-worker/nsjail/download.ruby.config.proto b/backend/windmill-worker/nsjail/download.ruby.config.proto new file mode 100644 index 0000000000..7b9a04f912 --- /dev/null +++ b/backend/windmill-worker/nsjail/download.ruby.config.proto @@ -0,0 +1,86 @@ +name: "gem install" + +mode: ONCE +hostname: "ruby" +log_level: ERROR +time_limit: 900 + +rlimit_as: 2048 +rlimit_cpu: 1000 +rlimit_fsize: 1024 +rlimit_nofile: 64 + +envar: "HOME=/user" +envar: "LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH" + +cwd: "/tmp" + +clone_newnet: false +clone_newuser: {CLONE_NEWUSER} + +skip_setsid: true +keep_caps: true +keep_env: true +mount_proc: true + + +mount { + src: "/bin" + dst: "/bin" + is_bind: true +} + +mount { + src: "/lib" + dst: "/lib" + is_bind: true +} + +mount { + src: "/lib64" + dst: "/lib64" + is_bind: true + mandatory: false +} + +mount { + src: "/usr" + dst: "/usr" + is_bind: true +} + +mount { + src: "/etc" + dst: "/etc" + is_bind: true +} + +mount { + src: "/dev/null" + dst: "/dev/null" + is_bind: true + rw: true +} + +mount { + dst: "/tmp" + fstype: "tmpfs" + rw: true + options: "size=500000000" +} + +mount { + src: "{TARGET}" + dst: "{TARGET}" + is_bind: true + mandatory: false + rw: true +} + +mount { + src: "/dev/urandom" + dst: "/dev/urandom" + is_bind: true +} + +{DEV} diff --git a/backend/windmill-worker/nsjail/lock.ruby.config.proto b/backend/windmill-worker/nsjail/lock.ruby.config.proto new file mode 100644 index 0000000000..4d6035a772 --- /dev/null +++ b/backend/windmill-worker/nsjail/lock.ruby.config.proto @@ -0,0 +1,79 @@ +name: "bundle lock" + +mode: ONCE +hostname: "ruby" +log_level: ERROR +time_limit: 900 + +rlimit_as: 2048 +rlimit_cpu: 1000 +rlimit_fsize: 1024 +rlimit_nofile: 64 + +envar: "HOME=/tmp" +envar: "LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH" + +cwd: "/tmp" + +clone_newnet: false +clone_newuser: {CLONE_NEWUSER} + +skip_setsid: true +keep_caps: true +keep_env: true +mount_proc: true + + +mount { + src: "/bin" + dst: "/bin" + is_bind: true +} + +mount { + src: "/lib" + dst: "/lib" + is_bind: true +} + +mount { + src: "/lib64" + dst: "/lib64" + is_bind: true + mandatory: false +} + +mount { + src: "/usr" + dst: "/usr" + is_bind: true +} + +mount { + src: "/etc" + dst: "/etc" + is_bind: true +} + +mount { + src: "/dev/null" + dst: "/dev/null" + is_bind: true + rw: true +} + +mount { + src: "{JOB_DIR}" + dst: "/tmp" + is_bind: true + mandatory: false + rw: true +} + +mount { + src: "/dev/urandom" + dst: "/dev/urandom" + is_bind: true +} + +{DEV} diff --git a/backend/windmill-worker/nsjail/run.ruby.config.proto b/backend/windmill-worker/nsjail/run.ruby.config.proto new file mode 100644 index 0000000000..539b87e147 --- /dev/null +++ b/backend/windmill-worker/nsjail/run.ruby.config.proto @@ -0,0 +1,113 @@ +name: "ruby run script" + +mode: ONCE +hostname: "ruby" +log_level: ERROR + +disable_rl: true + +cwd: "/tmp" + +clone_newnet: false +clone_newuser: {CLONE_NEWUSER} + +skip_setsid: true +keep_caps: false +keep_env: true +# mount_proc: true + +mount { + src: "/bin" + dst: "/bin" + is_bind: true +} + +mount { + src: "/lib" + dst: "/lib" + is_bind: true +} + + +mount { + src: "/lib64" + dst: "/lib64" + is_bind: true + mandatory: false +} + + +mount { + src: "/usr" + dst: "/usr" + is_bind: true +} + +mount { + src: "/dev/null" + dst: "/dev/null" + is_bind: true + rw: true +} + +mount { + dst: "/tmp" + fstype: "tmpfs" + rw: true + options: "size=500000000" +} + + +mount { + src: "{JOB_DIR}/main.rb" + dst: "/tmp/main.rb" + is_bind: true + mandatory: false +} + +mount { + src: "{JOB_DIR}/args.json" + dst: "/tmp/args.json" + is_bind: true +} + +mount { + src: "{JOB_DIR}/result.json" + dst: "/tmp/result.json" + rw: true + is_bind: true +} + +#mount { +# src: "{CACHE_DIR}" +# dst: "{CACHE_DIR}" +# is_bind: true +# mandatory: false +# } + +mount { + src: "/etc" + dst: "/etc" + is_bind: true +} + +mount { + src: "/dev/random" + dst: "/dev/random" + is_bind: true +} + +mount { + src: "/dev/urandom" + dst: "/dev/urandom" + is_bind: true +} + +iface_no_lo: true + +{SHARED_MOUNT} + +{SHARED_DEPENDENCIES} + + +{DEV} diff --git a/backend/windmill-worker/src/common.rs b/backend/windmill-worker/src/common.rs index bf5316f9eb..051101d727 100644 --- a/backend/windmill-worker/src/common.rs +++ b/backend/windmill-worker/src/common.rs @@ -12,7 +12,6 @@ use sha2::Digest; use sqlx::types::Json; use sqlx::{Pool, Postgres}; use tokio::process::Command; -use tokio::sync::{RwLock, Semaphore}; use tokio::{fs::File, io::AsyncReadExt}; #[cfg(feature = "parquet")] @@ -31,11 +30,10 @@ use windmill_common::{ variables::ContextualVariable, }; -use anyhow::{anyhow, bail, Result}; +use anyhow::{anyhow, Result}; use windmill_parser_sql::{s3_mode_extension, S3ModeArgs, S3ModeFormat}; use windmill_queue::MiniPulledJob; -use std::ops::AsyncFn; use std::path::Path; use std::{collections::HashMap, sync::Arc, time::Duration}; @@ -45,7 +43,7 @@ use windmill_common::{variables, DB}; use tokio::{io::AsyncWriteExt, time::Instant}; use crate::agent_workers::UPDATE_PING_URL; -use crate::{DISABLE_NSJAIL, JOB_DEFAULT_TIMEOUT, MAX_RESULT_SIZE, MAX_TIMEOUT_DURATION, PATH_ENV}; +use crate::{JOB_DEFAULT_TIMEOUT, MAX_RESULT_SIZE, MAX_TIMEOUT_DURATION, PATH_ENV}; use windmill_common::client::AuthedClient; pub async fn build_args_map<'a>( @@ -1072,561 +1070,6 @@ pub fn build_http_client(timeout_duration: std::time::Duration) -> error::Result .map_err(|e| Error::internal_err(format!("Error building http client: {e:#}"))) } -#[derive(Clone)] -pub struct RequiredDependency { - /// Expected directory of dependency in cache - /// For example: - /// /tmp/windmill/cache/python_311/rich==0.0.0 - /// IMPORTANT!: path should not end with '/' - pub path: String, - /// Name to use for S3 tars - /// If not specified will use top level directory of path. - pub custom_name: Option, - /// Display name - /// Name that will be used for console output and logging - /// If not specified will either use custom_name or top level directory of path. - pub short_name: Option, -} - -pub enum InstallStrategy { - /// Will invoke callback to install single dependency - Single(Arc Result + Send + Sync>), - /// Will try to pull S3 first and will invoke closure to install the rest - AllAtOnce(Arc) -> Result + Send + Sync>), -} -/// # General -/// -/// Languages that compile usually include dependencies in final executable. -/// When dynamic languages do not and runtime dependencies provided separately. -/// -/// This helper implies that the language is dynamic. -/// Python, Ruby, Java are dynamic and they can use this helper. -/// -/// # Features -/// -/// This helper will install all specified dependencies in parallel and if it is EE, cache to S3 -/// It has atomic success file, allowing to distinguish failed installations from succesfull. -/// -/// Besides that it provides console output and does logging. -/// -/// # Usage -/// -/// Most important arguments in this helper are `deps` and `install_fn` -/// -/// In `deps` you specify all dependencies that are needed to be on worker in order to execute script. -/// You don't know which are actually installed and which are not. -/// -/// `deps` is a vector of RequiredDependency. Check [RequiredDependency] for more context. -/// -/// After `deps` are provided helper will check each dependency and check if it is in cache, if not it will try to pull from S3 -/// and if it does not work either, it will invoke `install_fn` closure. -/// Closure arguments has dependency name as well as it`s expected path in cache. -/// Closure should return Command that will install dependency to asked place. -pub async fn par_install_language_dependencies<'a>( - deps: Vec, - language_name: &'a str, - installer_executable_name: &'a str, - platform_agnostic: bool, - concurrent_downloads: usize, - stdout_on_err: bool, - install_fn: InstallStrategy, - postinstall_cb: impl AsyncFn(Vec) -> Result<(), error::Error>, - job_id: &'a Uuid, - w_id: &'a str, - worker_name: &'a str, - conn: &Connection, -) -> anyhow::Result<()> { - #[cfg(not(all(feature = "enterprise", feature = "parquet")))] - let _ = (platform_agnostic, language_name); - - let total_time = std::time::Instant::now(); - - // Total to install - let mut not_installed = vec![]; - let total_to_install; - // let mut not_installed = vec![]; - let counter_arc = Arc::new(tokio::sync::Mutex::new(0)); - // Append logs with line like this: - // [9/21] + requests==2.32.3 << (S3) | in 57ms - #[allow(unused_assignments)] - async fn print_success( - mut s3_pull: bool, - mut s3_push: bool, - job_id: &Uuid, - w_id: &str, - req: &str, - req_tl: usize, - counter_arc: Arc>, - total_to_install: usize, - instant: std::time::Instant, - conn: &Connection, - ) { - #[cfg(not(all(feature = "enterprise", feature = "parquet")))] - { - (s3_pull, s3_push) = (false, false); - } - - #[cfg(all(feature = "enterprise", feature = "parquet"))] - if windmill_common::s3_helpers::OBJECT_STORE_SETTINGS - .read() - .await - .is_none() - { - (s3_pull, s3_push) = (false, false); - } - - let mut counter = counter_arc.lock().await; - *counter += 1; - - windmill_queue::append_logs( - job_id, - w_id, - format!( - "\n{}+ {}{}{}| in {}ms", - windmill_common::worker::pad_string( - &format!("[{}/{total_to_install}]", counter), - 9 - ), - // Because we want to align to max len [999/999] we take 9 - // 123456789 - windmill_common::worker::pad_string(&req, req_tl + 1), - // Margin to the right ^ - if s3_pull { "<< (S3) " } else { "" }, - if s3_push { " > (S3) " } else { "" }, - instant.elapsed().as_millis(), - ), - conn, - ) - .await; - // Drop lock, so next print success can fire - } - - let mut name_tl = 0; - struct NotInstalledDependency { - path: String, - custom_name: Option, - short_name: Option, - display_name: String, - } - { - let mut to_be_installed_is_used = false; - for RequiredDependency { - path, // - custom_name, - short_name, - } in deps.into_iter() - { - if path.ends_with("/") { - anyhow::bail!("Internal error: path should not end with '/'") - } - let display_name = short_name - .as_ref() - .or(custom_name.as_ref()) - .or(path.split("/").last().map(|e| e.to_owned()).as_ref()) - .unwrap_or_else(|| { - tracing::warn!( - workspace_id = %w_id, - job_id = %job_id, - "failed to parse top level directory name for {path}, fallback to full path.", - ); - - &path - }) - .to_owned(); - { - // Later will help us align text in log console - if display_name.len() > name_tl { - name_tl = display_name.len(); - } - } - // Will look like: /tmp/windmill/cache/lang/dependency.valid.windmill - if tokio::fs::metadata(path.clone() + ".valid.windmill") - .await - .is_err() - { - if !to_be_installed_is_used { - windmill_queue::append_logs( - job_id, - w_id, - format!("\n--- INSTALLATION ---\n\nTo be installed:\n\n"), - conn, - ) - .await; - to_be_installed_is_used = true; - } - windmill_queue::append_logs(job_id, w_id, format!("- {display_name}\n"), conn) - .await; - not_installed.push(NotInstalledDependency { - path, - custom_name, - short_name, - display_name, - }); - } - } - } - total_to_install = not_installed.len(); - if total_to_install == 0 { - return Ok(()); - } - #[cfg(all(feature = "enterprise", feature = "parquet"))] - let is_not_pro = !matches!( - windmill_common::ee_oss::get_license_plan().await, - windmill_common::ee_oss::LicensePlan::Pro - ); - #[cfg(all(feature = "enterprise", feature = "parquet"))] - if is_not_pro && matches!(install_fn, InstallStrategy::AllAtOnce(_)) { - windmill_queue::append_logs( - job_id, - w_id, - format!("\nLooking for packages on S3:\n"), - conn, - ) - .await; - } - - // Parallelism level (N) - let parallel_limit = // Semaphore will panic if value less then 1 - concurrent_downloads.clamp(1, 30); - - tracing::info!( - workspace_id = %w_id, - "Install parallel limit: {}, job: {}", - parallel_limit, - job_id - ); - - let mut handles = vec![]; - let semaphore = Arc::new(Semaphore::new(parallel_limit)); - let not_pulled = Arc::new(RwLock::new(vec![])); - // let mut handles = Vec::with_capacity(total_to_install); - for NotInstalledDependency { - // - path, - custom_name, - short_name, - display_name, - } in not_installed - { - let permit = semaphore.clone().acquire_owned().await; // Acquire a permit - - if let Err(_) = permit { - tracing::error!( - workspace_id = %w_id, - "Cannot acquire permit on semaphore, that can only mean that semaphore has been closed." - ); - break; - } - - let permit = permit.unwrap(); - - #[cfg(all(feature = "enterprise", feature = "parquet"))] - let s3_pull_future = if is_not_pro { - if let Some(os) = windmill_common::s3_helpers::get_object_store().await { - Some(crate::global_cache::pull_from_tar( - os, - path.clone(), - language_name.to_owned(), - custom_name.clone(), - platform_agnostic, - )) - } else { - None - } - } else { - None - }; - let child = { - if let InstallStrategy::Single(ref callback, ..) = install_fn { - let cmd = callback(RequiredDependency { - path: path.clone(), - custom_name: custom_name.clone(), - short_name: short_name.clone(), - })?; - tracing::debug!("{:?}", &cmd); - Some(start_child_process(cmd, &installer_executable_name, false).await?) - } else { - None - } - }; - - let ( - worker_name_2, - path_2, - display_name_2, - custom_name, - job_id_2, - w_id_2, - conn_2, - counter_arc, - language_name, - installer_executable_name, - not_pulled, - ) = ( - worker_name.to_owned(), - path.clone(), - display_name.clone(), - custom_name.clone(), - job_id.clone(), - w_id.to_owned(), - conn.clone(), - counter_arc.clone(), - language_name.to_owned(), - installer_executable_name.to_owned(), - not_pulled.clone(), - ); - #[cfg(not(all(feature = "enterprise", feature = "parquet")))] - let _ = language_name; - - let start = std::time::Instant::now(); - let handle = tokio::spawn(async move { - let _permit = permit; - - #[cfg(all(feature = "enterprise", feature = "parquet"))] - if let Some(s3_pull_future) = s3_pull_future { - if let Err(e) = s3_pull_future.await { - tracing::info!( - workspace_id = %w_id_2, - "No tarball was found for {:?} on S3 or different problem occured {job_id_2}:\n{e}", - &custom_name.clone().unwrap_or(path) - ); - } else { - // TODO: Refactor - // Create a file to indicate that installation was successfull - let valid_path = path_2.clone() + ".valid.windmill"; - // This is atomic operation, meaning, that it either completes and dependency is valid, - // or it does not and dependency is invalid and will be reinstalled next run - if let Err(e) = File::create(&valid_path).await { - tracing::error!( - workspace_id = %w_id_2, - job_id = %job_id_2, - "Failed to create {}!\n{e}\n - This file needed for jobs to function", - valid_path - ); - }; - print_success( - true, - false, - &job_id_2, - &w_id_2, - &display_name_2, - name_tl, - counter_arc, - total_to_install, - start, - &conn_2, - ) - .await; - return; - } - } - - let Some(child) = child else { - let mut lock = not_pulled.write().await; - lock.push(RequiredDependency { - path: path_2.clone(), - custom_name: custom_name.clone(), - short_name: short_name.clone(), - }); - return; - }; - if let Err(e) = crate::handle_child::handle_child( - &job_id_2, - &conn_2, - // TODO: Return mem_peak - &mut 0, - // TODO: Return canceld_by_ref - &mut None, - child, - !*DISABLE_NSJAIL, - &worker_name_2, - &w_id_2, - &installer_executable_name, - None, - false, - &mut None, - None, - ) - .await - { - windmill_queue::append_logs( - &job_id_2, - &w_id_2, - format!("error while installing {}: {e:?}", &display_name_2), - &conn_2, - ) - .await; - } else { - // if let Some(cb) = postinstall_cb { - // if let Err(e) = cb(vec![RequiredDependency { - // path: path_2.clone(), - // custom_name: custom_name.clone(), - // short_name: short_name.clone(), - // }]) - // .await - // { - // tracing::error!( - // workspace_id = %w_id_2, - // job_id = %job_id_2, - // "Postinstall callback failed!\n{e}\n - // This might affect execution", - // ); - // } - // } - print_success( - false, - true, - &job_id_2, - &w_id_2, - &display_name_2, - name_tl, - counter_arc, - total_to_install, - start, - &conn_2, - ) - .await; - // TODO: Refactor - // Create a file to indicate that installation was successfull - let valid_path = path_2.clone() + ".valid.windmill"; - // This is atomic operation, meaning, that it either completes and dependency is valid, - // or it does not and dependency is invalid and will be reinstalled next run - if let Err(e) = File::create(&valid_path).await { - tracing::error!( - workspace_id = %w_id_2, - job_id = %job_id_2, - "Failed to create {}!\n{e}\n - This file needed for jobs to function", - valid_path - ); - }; - #[cfg(all(feature = "enterprise", feature = "parquet"))] - { - if let Some(os) = windmill_common::s3_helpers::get_object_store().await { - tokio::spawn(async move { - if let Err(e) = crate::global_cache::build_tar_and_push( - os, - path_2, - language_name, - custom_name, - platform_agnostic, - ) - .await - { - tracing::warn!("failed to build tar and push: {e:?}"); - } - }); - } - } - } - }); - handles.push(handle); - } - - for handle in handles { - if let Err(e) = handle.await { - tracing::error!("Error joining handles: {e:?}"); - } - } - if !not_pulled.read().await.is_empty() { - if let InstallStrategy::AllAtOnce(ref callback, ..) = install_fn { - let not_pulled_copy = not_pulled.read().await.clone(); - windmill_queue::append_logs( - job_id, - w_id, - format!("\n\nFetching {} packages...\n", not_pulled_copy.len()), - &conn, - ) - .await; - let cmd = callback(not_pulled_copy.clone())?; - tracing::debug!("{:?}", &cmd); - let child = start_child_process(cmd, &installer_executable_name, false).await?; - let mut buf = "".to_owned(); - let pipe_stdout = if stdout_on_err { Some(&mut buf) } else { None }; - if let Err(e) = crate::handle_child::handle_child( - // &job_id, - &Uuid::nil(), - &conn, - // TODO: Return mem_peak - &mut 0, - // TODO: Return canceld_by_ref - &mut None, - child, - !*DISABLE_NSJAIL, - &worker_name, - &w_id, - &installer_executable_name, - None, - false, - &mut None, - pipe_stdout, - ) - .await - { - bail!(format!( - "error while installing dependencies: {e:?}\n{}", - buf - )); - } - { - postinstall_cb(not_pulled_copy.clone()).await?; - } - for RequiredDependency { path, custom_name: _custom_name, .. } in - not_pulled_copy.into_iter() - { - // TODO: Refactor - // Create a file to indicate that installation was successfull - let valid_path = path.clone() + ".valid.windmill"; - // This is atomic operation, meaning, that it either completes and dependency is valid, - // or it does not and dependency is invalid and will be reinstalled next run - if let Err(e) = File::create(&valid_path).await { - tracing::error!( - workspace_id = %w_id, - job_id = %job_id, - "Failed to create {}!\n{e}\n - This file needed for jobs to function", - valid_path - ); - }; - #[cfg(all(feature = "enterprise", feature = "parquet"))] - { - if let Some(os) = windmill_common::s3_helpers::get_object_store().await { - let language_name = language_name.to_owned(); - tokio::spawn(async move { - if let Err(e) = crate::global_cache::build_tar_and_push( - os, - path, - language_name, - _custom_name, - platform_agnostic, - ) - .await - { - tracing::warn!("failed to build tar and push: {e:?}"); - } - }); - } - } - } - } - } - { - let total_time = total_time.elapsed().as_millis(); - windmill_queue::append_logs( - &job_id, - w_id, - format!( - "\nDone. Time spent on installation phase: {}ms\n", - total_time - ), - conn, - ) - .await; - } - Ok(()) -} - #[derive(Clone)] pub struct S3ModeWorkerData { pub client: AuthedClient, diff --git a/backend/windmill-worker/src/java_executor.rs b/backend/windmill-worker/src/java_executor.rs index 0a6b13ddb9..5a779ad990 100644 --- a/backend/windmill-worker/src/java_executor.rs +++ b/backend/windmill-worker/src/java_executor.rs @@ -1,4 +1,4 @@ -use std::{collections::HashMap, path::PathBuf, process::Stdio, sync::Arc}; +use std::{collections::HashMap, path::PathBuf, process::Stdio}; use anyhow::{anyhow, bail}; use async_recursion::async_recursion; @@ -21,11 +21,13 @@ use windmill_queue::{append_logs, CanceledBy, MiniPulledJob}; use crate::{ common::{ - create_args_and_out_file, get_reserved_variables, par_install_language_dependencies, - read_result, start_child_process, OccupancyMetrics, RequiredDependency, + create_args_and_out_file, get_reserved_variables, read_result, start_child_process, + OccupancyMetrics, }, - handle_child, COURSIER_CACHE_DIR, DISABLE_NSJAIL, DISABLE_NUSER, JAVA_CACHE_DIR, - JAVA_REPOSITORY_DIR, MAVEN_REPOS, NO_DEFAULT_MAVEN, NSJAIL_PATH, PATH_ENV, PROXY_ENVS, + handle_child, + universal_pkg_installer::{par_install_language_dependencies_all_at_once, RequiredDependency}, + COURSIER_CACHE_DIR, DISABLE_NSJAIL, DISABLE_NUSER, JAVA_CACHE_DIR, JAVA_REPOSITORY_DIR, + MAVEN_REPOS, NO_DEFAULT_MAVEN, NSJAIL_PATH, PATH_ENV, PROXY_ENVS, }; use windmill_common::client::AuthedClient; @@ -275,14 +277,15 @@ async fn install<'a>( ); Ok(RequiredDependency { path, - custom_name: Some(format!("{group_id}:{artifact_id}:{version}")), - short_name: Some(format!("{artifact_id}:{version}")), + _s3_handle: format!("{group_id}:{artifact_id}:{version}"), + display_name: format!("{artifact_id}:{version}"), + custom_payload: (), }) } _ => anyhow::bail!("{line} is not parsable"), } }) - .collect::>>()?; + .collect::>>>()?; let classpath = deps .clone() @@ -307,14 +310,14 @@ async fn install<'a>( let job_dir = job_dir.to_owned(); let fetch_dir = format!("{JAVA_CACHE_DIR}/tmp-fetch-{}", Uuid::new_v4()); let fetch_dir2 = fetch_dir.clone(); - par_install_language_dependencies( + par_install_language_dependencies_all_at_once( deps, "java", "java", true, *JAVA_CONCURRENT_DOWNLOADS, true, - crate::common::InstallStrategy::AllAtOnce(Arc::new(move |dependencies| { + move |dependencies| { let mut cmd = Command::new(if cfg!(windows) { "java" } else { @@ -322,12 +325,8 @@ async fn install<'a>( }); let artifacts = dependencies .into_iter() - .map(|e| { - e.custom_name.ok_or(anyhow::anyhow!( - "Internal Error: Artifact name should be Some!" - )) - }) - .collect::>>()?; + .map(|e| e._s3_handle) + .collect::>(); cmd.env_clear() .current_dir(&job_dir) .env("PATH", PATH_ENV.as_str()) @@ -385,7 +384,7 @@ async fn install<'a>( } Ok(cmd) - })), + }, async move |_| { move_to_repository(&fetch_dir2, 0).await?; remove_dir_all(&fetch_dir2).await?; @@ -419,6 +418,7 @@ async fn install<'a>( &job.id, &job.workspace_id, worker_name, + !*DISABLE_NSJAIL, conn, ) .await?; diff --git a/backend/windmill-worker/src/lib.rs b/backend/windmill-worker/src/lib.rs index 3dfeba5c42..e917e32fba 100644 --- a/backend/windmill-worker/src/lib.rs +++ b/backend/windmill-worker/src/lib.rs @@ -13,6 +13,9 @@ mod bash_executor; #[cfg(feature = "java")] mod java_executor; +#[cfg(feature = "ruby")] +mod ruby_executor; + mod bun_executor; pub mod common; mod config; @@ -52,6 +55,7 @@ pub mod result_processor; mod rust_executor; mod sanitized_sql_params; mod schema; +mod universal_pkg_installer; mod worker; mod worker_flow; mod worker_lockfiles; diff --git a/backend/windmill-worker/src/ruby_executor.rs b/backend/windmill-worker/src/ruby_executor.rs new file mode 100644 index 0000000000..944ee5ee9c --- /dev/null +++ b/backend/windmill-worker/src/ruby_executor.rs @@ -0,0 +1,899 @@ +use std::{collections::HashMap, process::Stdio}; + +use anyhow::anyhow; +use const_format::concatcp; +use itertools::Itertools; +use regex::Regex; +use tokio::{ + fs::{self, File}, + io::{AsyncReadExt, AsyncWriteExt}, + process::Command, +}; +use url::Url; +use uuid::Uuid; +use windmill_common::{ + client::AuthedClient, + error::Error, + utils::calculate_hash, + worker::{write_file, Connection, RubyAnnotations}, +}; +use windmill_parser::Arg; +use windmill_parser_ruby::parse_ruby_signature; +use windmill_queue::{append_logs, CanceledBy, MiniPulledJob}; + +use crate::{ + common::{ + create_args_and_out_file, get_reserved_variables, read_result, start_child_process, + OccupancyMetrics, + }, + handle_child::{self}, + universal_pkg_installer::{par_install_language_dependencies_seq, RequiredDependency}, + DISABLE_NSJAIL, DISABLE_NUSER, NSJAIL_PATH, PATH_ENV, PROXY_ENVS, RUBY_CACHE_DIR, RUBY_REPOS, +}; +lazy_static::lazy_static! { + static ref RUBY_CONCURRENT_DOWNLOADS: usize = std::env::var("RUBY_CONCURRENT_DOWNLOADS").ok().map(|flag| flag.parse().unwrap_or(20)).unwrap_or(20); + static ref RUBY_PATH: String = std::env::var("RUBY_PATH").unwrap_or_else(|_| "/usr/bin/ruby".to_string()); + static ref BUNDLE_PATH: String = std::env::var("RUBY_BUNDLE_PATH").unwrap_or_else(|_| "/usr/bin/bundle".to_string()); + static ref GEM_PATH: String = std::env::var("RUBY_GEM_PATH").unwrap_or_else(|_| "/usr/bin/gem".to_string()); + static ref RUBY_PROXY_ENVS: Vec<(String, String)> = { + PROXY_ENVS + .clone() + .into_iter() + .map(|(k, v)| (k.to_lowercase(), v)) + .collect() + }; +} + +const NSJAIL_CONFIG_RUN_RUBY_CONTENT: &str = include_str!("../nsjail/run.ruby.config.proto"); +const NSJAIL_CONFIG_DOWNLOAD_RUBY_CONTENT: &str = + include_str!("../nsjail/download.ruby.config.proto"); +const NSJAIL_CONFIG_LOCK_RUBY_CONTENT: &str = include_str!("../nsjail/lock.ruby.config.proto"); + +#[cfg(debug_assertions)] +const DEV_CONF_NSJAIL: &'static str = r#" +# Mount nix store for nixos to work properly +mount { + src: "/nix/store" + dst: "/nix/store" + is_bind: true + mandatory: false +} +"#; + +#[cfg(not(debug_assertions))] +const DEV_CONF_NSJAIL: &'static str = ""; + +#[allow(dead_code)] +pub(crate) struct JobHandlerInput<'a> { + pub base_internal_url: &'a str, + pub canceled_by: &'a mut Option, + pub client: &'a AuthedClient, + pub parent_runnable_path: Option, + pub conn: &'a Connection, + pub envs: HashMap, + pub inner_content: &'a str, + pub job: &'a MiniPulledJob, + pub job_dir: &'a str, + pub mem_peak: &'a mut i32, + pub occupancy_metrics: &'a mut OccupancyMetrics, + pub requirements_o: Option<&'a String>, + pub shared_mount: &'a str, + pub worker_name: &'a str, +} + +pub async fn handle_ruby_job<'a>( + mut args: JobHandlerInput<'a>, +) -> Result, Error> { + // --- Prepare --- + { + prepare(&args).await?; + } + // --- Gen Lockfile --- + + let lockfile = resolve( + &args.job.id, + args.inner_content, + args.mem_peak, + args.canceled_by, + args.job_dir, + args.conn, + args.worker_name, + &args.job.workspace_id, + ) + .await?; + + // --- Install --- + + let ir = install(&mut args, lockfile).await?; + + // --- Execute --- + { + run(&mut args, ir).await?; + } + // --- Retrieve results --- + { + read_result(&args.job_dir, None).await + } +} +pub async fn prepare<'a>( + JobHandlerInput { + job, + conn, + job_dir, + inner_content, + client, + // + .. + }: &JobHandlerInput<'a>, +) -> Result<(), Error> { + create_args_and_out_file(&client, job, job_dir, conn).await?; + File::create(format!("{}/main.rb", job_dir)) + .await? + .write_all(&wrap(inner_content)?.into_bytes()) + .await?; + + let mini_wm_path = format!("{RUBY_CACHE_DIR}/gems/windmill-internal/windmill"); + if !std::fs::metadata(&mini_wm_path).is_ok() { + fs::create_dir_all(&mini_wm_path).await?; + + // Create inline.rb for dependency management (bundler/inline compatibility) + File::create(format!("{}/inline.rb", &mini_wm_path)) + .await? + .write_all(&wrap( + r#" +class GemfileProxy + def initialize + @gem_calls = [] + end + + def source(arg = nil, &block) + if arg.is_a?(String) && block_given? + # Handle the case where the argument is a string and a block is given + gemfile(&block) + elsif arg.is_a?(String) + # Handle the case where the argument is a string and no block is given + # Do nothing in this case + else + raise ArgumentError, "Invalid argument or block" + end + end + + def group(*args, **kwargs) + # Handle group calls if needed + end + + def ruby(*args, **kwargs) + warn "Custom Ruby runtime specifications (engine, engine_version, patchlevel) are not supported in this environment. Using system ruby" + end + + def gem(name, version = nil, require: nil, **kwargs) + @gem_calls << { name: name, version: version, require: require, kwargs: kwargs } + + case require + when false + # Skip requiring + when nil, true + begin + Kernel.require(name) + rescue LoadError => e + warn "WARN: Gem '#{name}' failed to auto-require. Try either:" + warn " `:require => false` or specify exact require path" + warn "Warn details: #{e.class}: #{e.message}" + end + else + begin + Kernel.require(require.to_s) + rescue LoadError => e + warn "WARN: Gem '#{name}' failed to auto-require. Try either:" + warn " `:require => false` or specify exact require path" + warn "Warn details: #{e.class}: #{e.message}" + end + end + end + + + def call_block(&block) + instance_eval(&block) if block_given? + end +end + +def gemfile(&block) + proxy = GemfileProxy.new + proxy.call_block(&block) +end + +def main +end +"# + )?.into_bytes()) + .await?; + + // Create mini.rb for Windmill client methods + File::create(format!("{}/mini.rb", &mini_wm_path)) + .await? + .write_all( + &wrap( + r##" +require 'net/http' +require 'uri' +require 'json' + +# Windmill mini client methods +def get_variable(path) + base_url = ENV['BASE_INTERNAL_URL'] + workspace = ENV['WM_WORKSPACE'] + token = ENV['WM_TOKEN'] + + uri = URI("#{base_url}/api/w/#{workspace}/variables/get_value/#{path}") + + http = Net::HTTP.new(uri.host, uri.port) + http.use_ssl = uri.scheme == 'https' + + request = Net::HTTP::Get.new(uri) + request['Authorization'] = "Bearer #{token}" + + response = http.request(request) + + if response.code == '200' + JSON.parse(response.body) + else + raise "Failed to get variable #{path}: #{response.code} #{response.message}" + end +end + +def get_resource(path) + base_url = ENV['BASE_INTERNAL_URL'] + workspace = ENV['WM_WORKSPACE'] + token = ENV['WM_TOKEN'] + + uri = URI("#{base_url}/api/w/#{workspace}/resources/get_value_interpolated/#{path}") + + http = Net::HTTP.new(uri.host, uri.port) + http.use_ssl = uri.scheme == 'https' + + request = Net::HTTP::Get.new(uri) + request['Authorization'] = "Bearer #{token}" + + response = http.request(request) + + if response.code == '200' + JSON.parse(response.body) + else + raise "Failed to get resource #{path}: #{response.code} #{response.message}" + end +end + +def main +end +"##, + )? + .into_bytes(), + ) + .await?; + } + Ok(()) +} + +pub async fn resolve<'a>( + job_id: &Uuid, + inner_content: &str, + mem_peak: &mut i32, + canceled_by: &mut Option, + job_dir: &str, + conn: &Connection, + worker_name: &str, + w_id: &str, +) -> Result { + lazy_static::lazy_static! { + static ref BUNDLER_RE: Regex = Regex::new(r#"(?m)^\s*require\s*['"]bundler/inline['"]"#).unwrap(); + static ref UNSUPPORTED_SOURCE_RE: Regex = Regex::new(r#"(?m)(?^\s*source\s*['"]\S+://(?\S+):(?\S+)@.*['"]\s*\n)"#).unwrap(); + static ref SOURCES_RE: Regex = Regex::new(r#"\S+://(?\S+:\S+)@(?\S*)"#).unwrap(); + } + + if BUNDLER_RE.find(&inner_content).is_some() { + return Err(anyhow!( + "Detected `require 'bundler/inline'` - please replace with `require 'windmill/inline'`. +Your Gemfile syntax will continue to work as-is." + ) + .into()); + } + + let gemfile: String = windmill_parser_ruby::parse_ruby_requirements(&inner_content)? + .lines() + .map(str::trim) + .filter(|s| !s.is_empty() && !s.starts_with('#')) + .join("\n"); + + if let Some(caps) = UNSUPPORTED_SOURCE_RE.captures(&gemfile) { + if let (Some(src_m), Some(usr_m), Some(passwd_m)) = + (caps.name("src"), caps.name("usr"), caps.name("passwd")) + { + let cause = src_m + .as_str() + .replace(usr_m.as_str(), "REDACTED") + .replace(passwd_m.as_str(), "REDACTED"); + + return Err(anyhow!("!> {cause} - inline source credentials are not supported at the moment. Please set up credentials in instance settings, if you do not have access to it, contact your administrator. If you need this feature please let us know.").into()); + } + } + + let mut file = File::create(job_dir.to_owned() + "/Gemfile").await?; + file.write_all(&gemfile.as_bytes()).await?; + + let req_hash = format!("ruby-{}", calculate_hash(&gemfile)); + if let Some(db) = conn.as_sql() { + if let Some(cached) = sqlx::query_scalar!( + "SELECT lockfile FROM pip_resolution_cache WHERE hash = $1", + req_hash + ) + .fetch_optional(db) + .await? + { + return Ok(cached); + } + } + let lock = { + append_logs( + job_id, + w_id, + format!("\n--- RESOLVING LOCKFILE ---\n"), + conn, + ) + .await; + + let mut cmd = if !cfg!(windows) && !*DISABLE_NSJAIL { + let nsjail_proto = format!("{}.lock.config.proto", Uuid::new_v4()); + let _ = write_file( + &job_dir, + &nsjail_proto, + &NSJAIL_CONFIG_LOCK_RUBY_CONTENT + .replace("{JOB_DIR}", job_dir) + .replace("{CLONE_NEWUSER}", &(!*DISABLE_NUSER).to_string()) + .replace("{DEV}", DEV_CONF_NSJAIL), // .replace("{BUILD}", &build_dir), + )?; + let mut cmd = Command::new(NSJAIL_PATH.as_str()); + cmd.args(vec!["--config", &nsjail_proto, "--", BUNDLE_PATH.as_str()]); + cmd + } else if cfg!(windows) { + Command::new("bundle.bat") + } else { + Command::new(BUNDLE_PATH.as_str()) + }; + + cmd.env_clear() + .current_dir(job_dir.to_owned()) + .envs(vec![ + ("PATH".to_owned(), PATH_ENV.clone()), + // Make sure there is nothing written to actual home + // This way we keep everything clean, organized and maintable + ("HOME".to_owned(), RUBY_CACHE_DIR.to_owned()), + ]) + .envs(RUBY_PROXY_ENVS.clone()); + + for repo in RUBY_REPOS.read().await.clone().unwrap_or_default() { + if let (Some(url), usr, Some(passwd)) = + (repo.domain(), repo.username(), repo.password()) + { + cmd.env( + format!( + "BUNDLE_{}", + url + // Align with bundlers' format. Example: + // BUNDLE_GEM1__EXAMPLE__COM + .replace(".", "__") + .to_uppercase() + // Remove trailing slashes + .replace("/", "") + ), + // BUNDLE_GEM1__EXAMPLE__COM=admin:123 + format!("{usr}:{passwd}"), + ); + } + } + cmd.args(&["lock", "--retry", "2"]) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + + #[cfg(windows)] + { + cmd.env("SystemRoot", crate::SYSTEM_ROOT.as_str()) + .env("USERPROFILE", crate::USERPROFILE_ENV.as_str()) + .env( + "TMP", + std::env::var("TMP").unwrap_or_else(|_| String::from("/tmp")), + ); + } + let child = start_child_process(cmd, "bundle", false).await?; + + handle_child::handle_child( + job_id, + conn, + mem_peak, + canceled_by, + child, + !*DISABLE_NSJAIL, + worker_name, + w_id, + "bundle", + None, + false, + &mut None, + // Some(&mut stdout), + None, + ) + .await?; + + let path_lock = format!("{job_dir}/Gemfile.lock"); + let mut file = File::open(path_lock).await?; + let mut req_content = "".to_string(); + file.read_to_string(&mut req_content).await?; + req_content + }; + + if let Some(db) = conn.as_sql() { + sqlx::query!( + "INSERT INTO pip_resolution_cache (hash, lockfile, expiration) VALUES ($1, $2, now() + ('3 days')::interval) ON CONFLICT (hash) DO UPDATE SET lockfile = $2", + req_hash, + lock.clone(), + ).fetch_optional(db).await?; + } + + append_logs(job_id, w_id, format!("\n{}", &lock), conn).await; + Ok(lock) +} + +struct InstallRes { + /// "/tmp/windmill/cache/ruby/gems/ab..xz-name-1.0.0/gems/name-1.0.0/lib:/tmp/windmill/..." + rubylib: String, + + /// ["/tmp/windmill/cache/ruby/gems/ab..xz-name-1.0.0", "/tmp/windmill/..."] + top_level_paths: Vec, +} + +async fn install<'a>( + JobHandlerInput { + worker_name, + job, + conn, + job_dir, + inner_content, + envs, + client, + parent_runnable_path, + .. + }: &mut JobHandlerInput<'a>, + lockfile: String, +) -> Result { + #[derive(Debug, Clone)] + enum CurrentSource { + GIT { remote: Option, revision: Option }, + GEM { remote: Option }, + INIT, + } + + #[derive(Debug, Clone)] + enum FinalSource { + #[allow(dead_code)] + GIT { + remote: String, + revision: String, + }, + GEM { + remote: String, + }, + } + + #[derive(Clone, Debug)] + struct CustomPayload { + source: FinalSource, + version: String, + pkg: String, + } + + let mut deps = vec![]; + let mut last_source = CurrentSource::INIT; + 'lock_lines: for line in lockfile.lines() { + // Trimed line + let tl = line.trim_start(); + if tl.starts_with("GIT") { + last_source = CurrentSource::GIT { remote: None, revision: None }; + continue 'lock_lines; + } else if tl.starts_with("GEM") { + last_source = CurrentSource::GEM { remote: None }; + continue 'lock_lines; + } + + const REMOTE: &str = "remote: "; + if line.contains(REMOTE) { + match &mut last_source { + CurrentSource::GIT { remote, .. } => remote.replace(tl.replace(REMOTE, "")), + CurrentSource::GEM { remote } => remote.replace(tl.replace(REMOTE, "")), + CurrentSource::INIT => return Err(Error::InternalErr("BUG on installation stage: detected initial enum variant at the stage it was not supposed to be at. Please report this issue.".to_owned())), + }; + continue 'lock_lines; + } + + const REVISION: &str = "revision: "; + if line.contains(REVISION) { + if let CurrentSource::GIT { revision, .. } = &mut last_source { + revision.replace(tl.replace(REVISION, "")); + } + continue 'lock_lines; + } + + // Check on untrimed line + if !line.starts_with(" ") || line.starts_with(" ") { + // "1234" "123456" + // For example: + // + // GIT + // remote: https://github.com/rails/rails.git + // revision: 8cb4f8ceffe375f64052579cd7a580bfdaf36d61 + // specs: + // actioncable (8.1.0.alpha) + // actionpack (= 8.1.0.alpha) + // activesupport (= 8.1.0.alpha) + // nio4r (~> 2.0) + // websocket-driver (>= 0.6.1) + // zeitwerk (~> 2.6) + // actionmailbox (8.1.0.alpha) + // actionpack (= 8.1.0.alpha) + // activejob (= 8.1.0.alpha) + // activerecord (= 8.1.0.alpha) + // activestorage (= 8.1.0.alpha) + // activesupport (= 8.1.0.alpha) + // mail (>= 2.8.0) + // actionmailer (8.1.0.alpha) + // ... + // + // In this snippet we only want actioncable, actionmailbox and actionmailer + // + // If it got the hit than that's not it, just skip + continue 'lock_lines; + } + + let buf = tl.replace(['(', ')'], ""); + let &[pkg, version, ..] = buf.split_whitespace().collect_vec().as_slice() else { + return Err(anyhow!("Cannot determine version and package name for: {}", tl).into()); + }; + + // Strip platform from version. E.g: + // 1.18.9-x86_64-darwin -> 1.18.9 + let version = version.split('-').next().unwrap_or(version); + + let custom_payload = CustomPayload { + version: version.into(), + pkg: pkg.into(), + source: match last_source.clone() { + CurrentSource::GIT { remote, revision } => FinalSource::GIT { + remote: remote.unwrap_or_default(), + revision: revision.unwrap_or_default(), + }, + CurrentSource::GEM { remote } => { + FinalSource::GEM { remote: remote.unwrap_or_default() } + }, + CurrentSource::INIT => return Err(Error::InternalErr("BUG on installation stage: detected initial enum variant at the stage it was not supposed to be at. Please report this issue.".to_owned())), + }, + }; + + // Calculate hash based on source + // Obfuscation is essential because remote can include credentials + let mut hash = calculate_hash(&format!("{:?}", custom_payload.clone())); + + // Use 32 characters which is 256 bits + hash.truncate(32); + + // Final format: + // 123...zx-activesupport-8.0.2 + // ^^^^^^^^ hash based on source and type (GEM or GIT) + let handle = format!("{}-{}-{}", hash, pkg, version); + let path = format!("{RUBY_CACHE_DIR}/gems/{}", &handle); + + deps.push(RequiredDependency { + path, + _s3_handle: handle, + display_name: tl.to_owned(), + custom_payload, + }); + } + + let job_dir = job_dir.to_owned(); + let jailed = !cfg!(windows) && !*DISABLE_NSJAIL; + let RubyAnnotations { verbose } = RubyAnnotations::parse(&inner_content); + let repos = RUBY_REPOS.read().await.clone().unwrap_or_default(); + let (envs, reserved_variables) = ( + envs.clone(), + get_reserved_variables(job, &client.token, conn, parent_runnable_path.clone()).await?, + ); + par_install_language_dependencies_seq( + deps.clone(), + "ruby", + "gem", + false, + *RUBY_CONCURRENT_DOWNLOADS, + // true, + // crate::common::InstallStrategy::Single(Arc::new(move |dependency| { + move |dependency| { + let mut cmd = if jailed { + std::fs::create_dir_all(&dependency.path)?; + let nsjail_proto = format!("{}.download.config.proto", Uuid::new_v4()); + let _ = write_file( + &job_dir, + &nsjail_proto, + &NSJAIL_CONFIG_DOWNLOAD_RUBY_CONTENT + .replace("{TARGET}", &dependency.path) + .replace("{CLONE_NEWUSER}", &(!*DISABLE_NUSER).to_string()) + .replace("{DEV}", DEV_CONF_NSJAIL), // .replace("{BUILD}", &build_dir), + )?; + let mut cmd = Command::new(NSJAIL_PATH.as_str()); + cmd.args(vec!["--config", &nsjail_proto, "--", GEM_PATH.as_str()]); + cmd + } else { + Command::new(if cfg!(windows) { + "gem.cmd" + } else { + GEM_PATH.as_str() + }) + }; + cmd.env_clear() + .current_dir(&job_dir) + .envs(vec![ + ("PATH".to_owned(), PATH_ENV.clone()), + // Make sure there is nothing written to actual home + // This way we keep everything clean, organized and maintable + ("HOME".to_owned(), RUBY_CACHE_DIR.to_owned()), + ]) + .envs(RUBY_PROXY_ENVS.clone()); + + // Figure out source + let source = { + let source = match dependency.custom_payload.source { + FinalSource::GIT { .. } => return Err(anyhow!("GIT is not supported").into()), + FinalSource::GEM { remote } => remote, + } + .trim() + .to_owned(); + + let src_url = Url::parse(&source)?; + repos + .iter() + .find(|inst_url| { + inst_url.domain().is_some() + && (inst_url.domain(), inst_url.path()) + == (src_url.domain(), src_url.path()) + }) + .map(Url::to_string) + .unwrap_or(source) + }; + + cmd.args(&[ + "install", + &dependency.custom_payload.pkg, + "--version", + &dependency.custom_payload.version, + "--install-dir", + &dependency.path, + // Disable transitive dependencies! + "--ignore-dependencies", + "--no-document", + // Do not use default sources + "--clear-sources", + // Specify the one from lockfile + "--source", + source.as_str(), + ]) + .envs(envs.clone()) + .envs(reserved_variables.clone()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + + if !verbose { + // Make it output minimal info + cmd.args(&["--quiet", "--silent"]); + } + + #[cfg(windows)] + { + cmd.env("SystemRoot", crate::SYSTEM_ROOT.as_str()) + .env("USERPROFILE", crate::USERPROFILE_ENV.as_str()) + .env( + "TMP", + std::env::var("TMP").unwrap_or_else(|_| String::from("/tmp")), + ) + .env( + "SYSTEMDRIVE", + std::env::var("SYSTEMDRIVE").unwrap_or_else(|_| String::from("C:")), + ); + } + + Ok(cmd) + }, + // async move |_| Ok(()), + &job.id, + &job.workspace_id, + worker_name, + jailed, + conn, + ) + .await?; + + let mut res = InstallRes { + rubylib: deps + .iter() + .map(|rd| { + format!( + "{}/gems/{}-{}/lib", + rd.path, rd.custom_payload.pkg, rd.custom_payload.version + ) + }) + .join(":"), + top_level_paths: deps.iter().map(|rd| rd.path.clone()).collect_vec(), + }; + // Include builtin windmill client + { + const WM_INTERNAL: &str = concatcp!(RUBY_CACHE_DIR, "/gems/windmill-internal"); + res.top_level_paths.push(WM_INTERNAL.to_owned()); + res.rubylib += format!(":{WM_INTERNAL}").as_str(); + } + Ok(res) +} + +async fn run<'a>( + JobHandlerInput { + occupancy_metrics, + mem_peak, + canceled_by, + worker_name, + job, + conn, + job_dir, + shared_mount, + client, + envs, + base_internal_url, + parent_runnable_path, + .. + }: &mut JobHandlerInput<'a>, + InstallRes { rubylib, top_level_paths }: InstallRes, +) -> Result<(), Error> { + let reserved_variables = + get_reserved_variables(job, &client.token, conn, parent_runnable_path.clone()).await?; + + let child = if !cfg!(windows) && !*DISABLE_NSJAIL { + append_logs( + &job.id, + &job.workspace_id, + format!("\n--- ISOLATED RUBY CODE EXECUTION ---\n"), + conn, + ) + .await; + let shared_deps = top_level_paths + .into_iter() + .map(|pp| { + format!( + r#" +mount {{ + src: "{pp}" + dst: "{pp}" + is_bind: true + rw: false +}} + "# + ) + }) + .join("\n"); + + write_file( + job_dir, + "run.config.proto", + &NSJAIL_CONFIG_RUN_RUBY_CONTENT + .replace("{JOB_DIR}", job_dir) + .replace("{SHARED_MOUNT}", &shared_mount) + .replace("{SHARED_DEPENDENCIES}", &shared_deps) + .replace("{DEV}", DEV_CONF_NSJAIL) + .replace("{CLONE_NEWUSER}", &(!*DISABLE_NUSER).to_string()), + )?; + let mut cmd = Command::new(NSJAIL_PATH.as_str()); + cmd.env_clear() + .current_dir(job_dir) + .env("PATH", PATH_ENV.as_str()) + .env("BASE_INTERNAL_URL", base_internal_url) + .env("RUBYLIB", rubylib.as_str()) + .envs(envs) + .envs(reserved_variables) + .envs(RUBY_PROXY_ENVS.clone()) + .envs(PROXY_ENVS.clone()) + .args(vec![ + "--config", + "run.config.proto", + "--", + RUBY_PATH.as_str(), + "main.rb", + ]); + cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); + + start_child_process(cmd, NSJAIL_PATH.as_str(), false).await? + } else { + append_logs( + &job.id, + &job.workspace_id, + format!("\n--- RUBY CODE EXECUTION ---\n"), + conn, + ) + .await; + + let mut cmd = Command::new(if cfg!(windows) { + "ruby.exe" + } else { + RUBY_PATH.as_str() + }); + + #[cfg(windows)] + let rubylib = rubylib.replace(":", ";"); + + cmd.env_clear() + .current_dir(job_dir.to_owned()) + .env("PATH", PATH_ENV.as_str()) + .env("RUBYLIB", rubylib.as_str()) + .env("BASE_INTERNAL_URL", base_internal_url) + .envs(reserved_variables) + .envs(RUBY_PROXY_ENVS.clone()) + .envs(PROXY_ENVS.clone()) + .envs(envs); + + cmd.args(&["main.rb"]) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + + #[cfg(windows)] + { + cmd.env("SystemRoot", crate::SYSTEM_ROOT.as_str()) + .env("USERPROFILE", crate::USERPROFILE_ENV.as_str()) + .env( + "TMP", + std::env::var("TMP").unwrap_or_else(|_| String::from("/tmp")), + ); + } + start_child_process(cmd, "ruby", false).await? + }; + handle_child::handle_child( + &job.id, + conn, + mem_peak, + canceled_by, + child, + !*DISABLE_NSJAIL, + worker_name, + &job.workspace_id, + "ruby", + job.timeout, + false, + &mut Some(occupancy_metrics), + None, + ) + .await?; + Ok(()) +} +fn wrap(inner_content: &str) -> Result { + let sig = parse_ruby_signature(inner_content)?; + let spread = sig + .args + .clone() + .into_iter() + .map(|Arg { name, .. }| format!("a[\"{}\"]", name)) + .collect_vec() + .join(","); + Ok( + r#"INNER_CONTENT + +require 'json' +a = JSON.parse(File.read("args.json")) +res = main(SPREAD) +File.open("result.json", "w") do |file| + file.write(JSON.generate(res)) +end + "# + .replace("INNER_CONTENT", inner_content) + .replace("SPREAD", &spread), // .replace("TRANSFORM", transform) + ) +} diff --git a/backend/windmill-worker/src/universal_pkg_installer.rs b/backend/windmill-worker/src/universal_pkg_installer.rs new file mode 100644 index 0000000000..1e4a8c2d39 --- /dev/null +++ b/backend/windmill-worker/src/universal_pkg_installer.rs @@ -0,0 +1,767 @@ +use std::sync::Arc; + +use anyhow::bail; +use itertools::Itertools; +use process_wrap::tokio::TokioChildWrapper; +use tokio::{ + fs::File, + process::Command, + sync::{broadcast::Sender, OwnedSemaphorePermit, RwLock, Semaphore}, + task::JoinHandle, +}; +use uuid::Uuid; +use windmill_common::{error, worker::Connection}; + +use crate::{common::start_child_process, DISABLE_NSJAIL}; + +#[derive(Clone, Debug)] +pub struct RequiredDependency { + /// Expected directory of dependency in cache + /// For example: + /// /tmp/windmill/cache/python_311/rich==0.0.0 + /// IMPORTANT!: path should not end with '/' + pub path: String, + /// Name to use for S3 tars + pub _s3_handle: String, + /// Display name + /// Name that will be used for console output and logging + pub display_name: String, + /// Custom payload can be used for passing information easily. If you wish not to use it just leave '()' + pub custom_payload: T, +} + +#[allow(dead_code)] +pub enum InstallStrategy { + /// Will invoke callback to install single dependency + Single(Arc) -> Result + Send + Sync>), + /// Will try to pull S3 first and will invoke closure to install the rest + AllAtOnce(Arc>>>), +} + +/// # General +/// +/// Languages that compile usually include dependencies in final executable. +/// When dynamic languages do not and runtime dependencies are provided separately. +/// +/// This helper assumes that the language is dynamic. +/// Python, Ruby, Java are dynamic and they can use this helper. +/// +/// # Features +/// +/// This helper will install all specified dependencies in parallel and if it is EE, cache to S3 +/// It has atomic success file, allowing to distinguish failed installations from succesfull. +/// +/// Besides that it provides console output and does logging. +/// +/// # Usage +/// +/// Most important arguments in this helper are `deps` and `install_fn` +/// +/// In `deps` you specify all dependencies that are needed to be on worker in order to execute script. +/// You don't know which are actually installed and which are not. +/// +/// `deps` is a vector of RequiredDependency. Check [RequiredDependency] for more context. +/// +/// After `deps` are provided helper will check each dependency and check if it is in cache, if not it will try to pull from S3 +/// and if it does not work either, it will invoke `install_fn` closure. +/// Closure arguments has dependency name as well as its expected path in cache. +/// Closure should return Command that will install dependency to asked place. +#[allow(dead_code)] +pub async fn par_install_language_dependencies_all_at_once< + 'a, + T: Clone + std::marker::Send + Sync + 'a + 'static, +>( + deps: Vec>, + _language_name: &'a str, + installer_executable_name: &'a str, + _platform_agnostic: bool, + concurrent_downloads: usize, + stdout_on_err: bool, + callback: impl Fn(Vec>) -> Result + + Send + + Sync + + 'static, + postinstall_cb: impl AsyncFn(Vec>) -> Result<(), error::Error>, + job_id: &'a Uuid, + w_id: &'a str, + worker_name: &'a str, + jailed: bool, + conn: &'a Connection, +) -> anyhow::Result<()> { + #[cfg(all(feature = "enterprise", feature = "parquet"))] + let is_not_pro = !matches!( + windmill_common::ee_oss::get_license_plan().await, + windmill_common::ee_oss::LicensePlan::Pro + ); + #[cfg(all(feature = "enterprise", feature = "parquet"))] + if is_not_pro { + windmill_queue::append_logs( + job_id, + w_id, + format!("\nLooking for packages on S3:\n"), + conn, + ) + .await; + } + let total_time = std::time::Instant::now(); + let (missing, name_max_length) = filter_to_missing(deps, job_id, w_id, jailed, conn).await?; + if missing.is_empty() { + return Ok(()); + } + let to_batch_install = Arc::new(RwLock::new(vec![])); + let handles = spawn_wrapped_installation_threads( + missing, + name_max_length, + InstallStrategy::AllAtOnce(to_batch_install.clone()), + installer_executable_name, + concurrent_downloads, + job_id, + w_id, + worker_name, + conn, + _language_name, + _platform_agnostic, + ) + .await?; + let installation_res = process_handles(handles, w_id).await; + if !to_batch_install.read().await.is_empty() { + let for_all_at_once_copy = to_batch_install.read().await.clone(); + windmill_queue::append_logs( + job_id, + w_id, + format!("\n\nFetching {} packages...\n", for_all_at_once_copy.len()), + &conn, + ) + .await; + let cmd = callback(for_all_at_once_copy.clone())?; + let child = start_child_process(cmd, &installer_executable_name, false).await?; + let mut buf = "".to_owned(); + let pipe_stdout = if stdout_on_err { Some(&mut buf) } else { None }; + + if let Err(e) = crate::handle_child::handle_child( + &(if pipe_stdout.is_some() { + Uuid::nil() + } else { + *job_id + }), + conn, + // TODO: Return mem_peak + &mut 0, + // TODO: Return canceld_by_ref + &mut None, + child, + !*DISABLE_NSJAIL, + &worker_name, + &w_id, + &installer_executable_name, + None, + false, + &mut None, + pipe_stdout, + ) + .await + { + bail!(format!( + "\nerror while installing dependencies: {e:?}\n{}", + buf + )); + } + { + postinstall_cb(for_all_at_once_copy.clone()).await?; + } + for RequiredDependency { path, _s3_handle, .. } in for_all_at_once_copy.into_iter() { + mark_success(path.clone(), job_id, w_id).await; + #[cfg(all(feature = "enterprise", feature = "parquet"))] + { + if let Some(os) = windmill_common::s3_helpers::get_object_store().await { + let language_name = _language_name.to_owned(); + tokio::spawn(async move { + if let Err(e) = crate::global_cache::build_tar_and_push( + os, + path, + language_name, + Some(_s3_handle), + _platform_agnostic, + ) + .await + { + tracing::warn!("failed to build tar and push: {e:?}"); + } + }); + } + } + } + } + finish_installation(total_time, job_id, w_id, conn).await; + installation_res +} + +/// # General +/// +/// Languages that compile usually include dependencies in final executable. +/// When dynamic languages do not and runtime dependencies are provided separately. +/// +/// This helper assumes that the language is dynamic. +/// Python, Ruby, Java are dynamic and they can use this helper. +/// +/// # Features +/// +/// This helper will install all specified dependencies in parallel and if it is EE, cache to S3 +/// It has atomic success file, allowing to distinguish failed installations from succesfull. +/// +/// Besides that it provides console output and does logging. +/// +/// # Usage +/// +/// Most important arguments in this helper are `deps` and `install_fn` +/// +/// In `deps` you specify all dependencies that are needed to be on worker in order to execute script. +/// You don't know which are actually installed and which are not. +/// +/// `deps` is a vector of RequiredDependency. Check [RequiredDependency] for more context. +/// +/// After `deps` are provided helper will check each dependency and check if it is in cache, if not it will try to pull from S3 +/// and if it does not work either, it will invoke `install_fn` closure. +/// Closure arguments has dependency name as well as it`s expected path in cache. +/// Closure should return Command that will install dependency to asked place. +#[allow(dead_code)] +pub async fn par_install_language_dependencies_seq< + 'a, + T: Clone + std::marker::Send + Sync + 'a + 'static, +>( + deps: Vec>, + _language_name: &'a str, + installer_executable_name: &'a str, + _platform_agnostic: bool, + concurrent_downloads: usize, + callback: impl Fn(RequiredDependency) -> Result + Send + Sync + 'static, + job_id: &'a Uuid, + w_id: &'a str, + worker_name: &'a str, + jailed: bool, + conn: &'a Connection, +) -> anyhow::Result<()> { + #[cfg(all(feature = "enterprise", feature = "parquet"))] + let is_not_pro = !matches!( + windmill_common::ee_oss::get_license_plan().await, + windmill_common::ee_oss::LicensePlan::Pro + ); + #[cfg(all(feature = "enterprise", feature = "parquet"))] + if is_not_pro { + windmill_queue::append_logs( + job_id, + w_id, + format!("\nLooking for packages on S3:\n"), + conn, + ) + .await; + } + let total_time = std::time::Instant::now(); + let (missing, name_max_length) = filter_to_missing(deps, job_id, w_id, jailed, conn).await?; + if missing.is_empty() { + return Ok(()); + } + let handles = spawn_wrapped_installation_threads( + missing, + name_max_length, + InstallStrategy::Single(Arc::new(callback)), + installer_executable_name, + concurrent_downloads, + job_id, + w_id, + worker_name, + conn, + _language_name, + _platform_agnostic, + ) + .await?; + + let installation_res = process_handles(handles, w_id).await; + finish_installation(total_time, job_id, w_id, conn).await; + installation_res +} + +type NameMaxLength = usize; +async fn filter_to_missing<'a, T: Clone + std::marker::Send + Sync + 'a + 'static>( + mut deps: Vec>, + job_id: &Uuid, + w_id: &str, + jailed: bool, + conn: &Connection, +) -> anyhow::Result<(Vec>, NameMaxLength)> { + // Unique to flatten all same values + deps = deps.into_iter().unique_by(|rd| rd.path.clone()).collect(); + // Total to install + let mut missing = vec![]; + // Name max length + let mut name_ml = 0; + for rd in deps.into_iter() { + let display_name = rd.display_name.clone(); + if rd.path.ends_with("/") { + anyhow::bail!("Internal error: path should not end with '/'") + } + { + // Later will help us align text in log console + if display_name.len() > name_ml { + name_ml = rd.display_name.len(); + } + } + // Will look like: /tmp/windmill/cache/lang/dependency.valid.windmill + if tokio::fs::metadata(rd.path.clone() + ".valid.windmill") + .await + .is_err() + { + missing.push(rd); + } + } + if !missing.is_empty() { + windmill_queue::append_logs( + job_id, + w_id, + if jailed { + format!("\n--- ISOLATED INSTALLATION ---\n\nTo be installed:\n\n") + } else { + format!("\n--- INSTALLATION ---\n\nTo be installed:\n\n") + }, + conn, + ) + .await; + let to_log = missing + .iter() + .map(|rd| format!("- {}", &rd.display_name)) + .join("\n") + + "\n"; + + windmill_queue::append_logs(job_id, w_id, to_log, conn).await; + } + Ok((missing, name_ml)) +} + +enum Action { + Install(Box), + AddToBulk(Arc>>>), +} +struct TaskKiller(tokio::sync::broadcast::Sender); +impl Drop for TaskKiller { + fn drop(&mut self) { + // We don't care if it actually stopped anything or not. + // In some cases it will fire and actually stop + // In other cases do nothing + #[allow(unused_must_use)] + self.0.send("Installation failed".to_owned()); + } +} +// Callback will be invoked only if could not pull from S3 +async fn spawn_wrapped_installation_threads< + 'a, + T: Clone + std::marker::Send + Sync + 'a + 'static, +>( + missing: Vec>, + name_ml: usize, + strategy: InstallStrategy, + installer_executable_name: &str, + concurrent_downloads: usize, + job_id: &Uuid, + w_id: &str, + worker_name: &str, + conn: &Connection, + _language_name: &str, + _platform_agnostic: bool, +) -> anyhow::Result<( + Vec>>, + tokio::sync::broadcast::Sender<()>, +)> { + // Semaphore will panic if value less then 1 + let parallel_limit = concurrent_downloads.clamp(1, 30); + tracing::info!( + workspace_id = %w_id, + "Install parallel limit: {}, job: {}", + parallel_limit, + job_id + ); + + let (mut handles, semaphore, total_to_install, counter_arc) = ( + vec![], + Arc::new(Semaphore::new(parallel_limit)), + missing.len(), + Arc::new(tokio::sync::Mutex::new(0)), + ); + + // Pretty sensitive. Single drop will fail installation + let (kill_tx, ..) = tokio::sync::broadcast::channel::(10); + // ^^^^^^^ Original will go into listen_to_cancel + // + // But before that it will be used to populate t and r for every thread + let trxs: Vec<( + tokio::sync::broadcast::Sender, + tokio::sync::broadcast::Receiver, + )> = (0..missing.len()) + .map(|_| (kill_tx.clone(), kill_tx.subscribe())) + .collect(); + + // Listen to cancel events and stop jobs + // NOTE: + // once closer is dropped, the listener will be closed + let closer = listen_to_cancel(job_id.clone(), w_id.to_owned(), conn.clone(), kill_tx).await; + + for (dep, (kill_tx, mut kill_rx)) in missing.into_iter().zip(trxs) { + let permit = semaphore.clone().acquire_owned().await; // Acquire a permit + + if let Err(_) = permit { + tracing::error!( + workspace_id = %w_id, + "Cannot acquire permit on semaphore, that can only mean that semaphore has been closed." + ); + break; + } + + let permit = permit.unwrap(); + + let action = match strategy { + InstallStrategy::Single(ref callback) => Action::Install( + start_child_process(callback(dep.clone())?, &installer_executable_name, false) + .await?, + ), + InstallStrategy::AllAtOnce(ref rw_lock) => Action::AddToBulk(Arc::clone(rw_lock)), + }; + let task_fut = try_install_one_detached( + dep, + installer_executable_name.to_owned(), + job_id.clone(), + w_id.to_owned(), + worker_name.to_owned(), + conn.to_owned(), + counter_arc.clone(), + total_to_install, + name_ml, + action, + _language_name.to_owned(), + _platform_agnostic, + permit, + TaskKiller(kill_tx), + ); + handles.push(tokio::spawn(async move { + tokio::select! { + reason = kill_rx.recv() => return Err(anyhow::anyhow!("Installation stopped. Reason: {:?}", reason)), + r = task_fut => return r + }; + })); + } + + Ok((handles, closer)) +} +/// Do not drop the returned sender! As soon as you drop it the polling thread will stop +pub async fn listen_to_cancel( + job_id: Uuid, + w_id: String, + conn: Connection, + killpill: tokio::sync::broadcast::Sender, +) -> tokio::sync::broadcast::Sender<()> { + let (close_tx, mut close_rx) = tokio::sync::broadcast::channel::<()>(1); + tokio::spawn(async move { + 'outer: loop { + tokio::select! { + _ = tokio::time::sleep(tokio::time::Duration::from_secs(1)) => { + // TODO: Add memory usage tracking + if crate::worker_utils::ping_job_status(&conn, &job_id, None, None).await.map(|r| r.canceled_by.is_some()).unwrap_or(false){ + tracing::info!( + // If there is listener on other side, + workspace_id = %w_id, + "cancelling installations", + ); + if let Err(ref e) = killpill.send("Job was canceled".to_owned()) { + tracing::error!( + // If there is listener on other side, + workspace_id = %w_id, + "failed to send done: Probably receiving end closed too early or have not opened yet\n{}", + // If there is no listener, it will be dropped safely + e + ); + } + // Stop + break 'outer; + } + + }, + _ = close_rx.recv() => break 'outer, + } + } + }); + + // We will return the sender that can stop created thread. + // It is relatively safe, since if this handle is being dropped from the gecko the thread will stop immediately + // but it will also chainreaction all installation threads, so be carefull + close_tx +} + +async fn try_install_one_detached<'a, T: Clone + std::marker::Send + Sync + 'a + 'static>( + dep: RequiredDependency, + installer_executable_name: String, + job_id: Uuid, + w_id: String, + worker_name: String, + conn: Connection, + counter_arc: Arc>, + total_to_install: usize, + name_ml: usize, + action: Action, + _language_name: String, + _platform_agnostic: bool, + _permit: OwnedSemaphorePermit, + // If dropped the entire installation fails and all installation threads are being stopped + // That's why we just pass it to return so it is not being dropped + kill_all_tasks: TaskKiller, +) -> anyhow::Result { + let start = std::time::Instant::now(); + + #[cfg(all(feature = "enterprise", feature = "parquet"))] + let is_not_pro = !matches!( + windmill_common::ee_oss::get_license_plan().await, + windmill_common::ee_oss::LicensePlan::Pro + ); + + #[cfg(all(feature = "enterprise", feature = "parquet"))] + let s3_pull_future = if is_not_pro { + if let Some(os) = windmill_common::s3_helpers::get_object_store().await { + Some(crate::global_cache::pull_from_tar( + os, + dep.path.clone(), + _language_name.to_owned(), + Some(dep._s3_handle.clone()), + _platform_agnostic, + )) + } else { + None + } + } else { + None + }; + + #[cfg(all(feature = "enterprise", feature = "parquet"))] + if let Some(s3_pull_future) = s3_pull_future { + if let Err(e) = s3_pull_future.await { + tracing::info!( + workspace_id = %w_id, + "No tarball was found for {:?} on S3 or different problem occured {job_id}:\n{e}", + &dep._s3_handle.clone() + ); + } else { + mark_success(dep.path, &job_id, &w_id).await; + print_success( + true, + false, + &job_id, + &w_id, + &dep.display_name, + name_ml, + counter_arc, + total_to_install, + start, + &conn, + ) + .await; + return Ok(kill_all_tasks); + } + } + let child = match action { + Action::Install(child) => child, + Action::AddToBulk(rw_lock) => { + rw_lock.write().await.push(dep.clone()); + return Ok(kill_all_tasks); + } + }; + if let Err(e) = crate::handle_child::handle_child( + &job_id, + &conn, + // TODO: Return mem_peak + &mut 0, + // TODO: Return canceld_by_ref + &mut None, + child, + !*DISABLE_NSJAIL, + &worker_name, + &w_id, + &installer_executable_name, + None, + false, + &mut None, + None, + ) + .await + { + windmill_queue::append_logs( + &job_id, + &w_id, + format!( + "\n[x] - error while installing {}: {e:?}", + &dep.display_name + ), + &conn, + ) + .await; + bail!(format!( + "\n error while installing dependencies: {e:?}\n{}", + &dep.display_name + )); + } else { + mark_success(dep.path.clone(), &job_id, &w_id).await; + print_success( + false, + true, + &job_id, + &w_id, + &dep.display_name, + name_ml, + counter_arc, + total_to_install, + start, + &conn, + ) + .await; + + #[cfg(all(feature = "enterprise", feature = "parquet"))] + { + if let Some(os) = windmill_common::s3_helpers::get_object_store().await { + let language_name = _language_name.to_string(); + let platform_agnostic = _platform_agnostic; + let path = dep.path.clone(); + let handle = dep._s3_handle.clone(); + tokio::spawn(async move { + if let Err(e) = crate::global_cache::build_tar_and_push( + os, + path, + language_name, + Some(handle), + platform_agnostic, + ) + .await + { + tracing::warn!("failed to build tar and push: {e:?}"); + } + }); + } + } + } + + Ok(kill_all_tasks) +} + +// Create a file to indicate that installation was successfull +async fn mark_success(path: String, job_id: &Uuid, w_id: &str) { + let valid_path = path + ".valid.windmill"; + // This is atomic operation, meaning, that it either completes and dependency is valid, + // or it does not and dependency is invalid and will be reinstalled next run + if let Err(e) = File::create(&valid_path).await { + tracing::error!( + workspace_id = %w_id, + job_id = %job_id, + "Failed to create {}!\n{e}\n + This file needed for jobs to function", + valid_path + ); + }; +} +// Append logs with line like this: +// [9/21] + requests==2.32.3 << (S3) | in 57ms +#[allow(unused_assignments)] +async fn print_success( + mut s3_pull: bool, + mut s3_push: bool, + job_id: &Uuid, + w_id: &str, + req: &str, + req_tl: usize, + counter_arc: Arc>, + total_to_install: usize, + instant: std::time::Instant, + conn: &Connection, +) { + #[cfg(not(all(feature = "enterprise", feature = "parquet")))] + { + (s3_pull, s3_push) = (false, false); + } + + #[cfg(all(feature = "enterprise", feature = "parquet"))] + if windmill_common::s3_helpers::OBJECT_STORE_SETTINGS + .read() + .await + .is_none() + { + (s3_pull, s3_push) = (false, false); + } + + let mut counter = counter_arc.lock().await; + *counter += 1; + + windmill_queue::append_logs( + job_id, + w_id, + format!( + "\n{}+ {}{}{}| in {}ms", + windmill_common::worker::pad_string(&format!("[{}/{total_to_install}]", counter), 9), + // Because we want to align to max len [999/999] we take 9 + // 123456789 + windmill_common::worker::pad_string(&req, req_tl + 1), + // Margin to the right ^ + if s3_pull { "<< (S3) " } else { "" }, + if s3_push { " > (S3) " } else { "" }, + instant.elapsed().as_millis(), + ), + conn, + ) + .await; + // Drop lock, so next print success can fire +} + +async fn process_handles( + (handles, closer): (Vec>>, Sender<()>), + w_id: &str, +) -> anyhow::Result<()> { + let mut killers = vec![]; + for handle in handles { + match handle + .await + .unwrap_or(Err(anyhow::anyhow!("Problem by joining handle"))) + { + // __________< Cannot drop just yet. + Ok(kill_tasks) => killers.push(kill_tasks), + Err(e) => { + tracing::warn!( + workspace_id = %w_id, + "Env installation failed: {:?}", + e + ); + // We can safely return, + // it will drop `closer` + // which will drop first kill_tx for all installation threads + // which will trigger chain reaction and kill every installation + return Err(e); + } + } + } + + // Only now we can be sure there is no installation thread running + // we can safely stop poller + drop(closer); + // Drop ONLY after we processed all handles + drop(killers); + Ok(()) +} +async fn finish_installation( + total_time: std::time::Instant, + job_id: &Uuid, + w_id: &str, + conn: &Connection, +) { + let total_time = total_time.elapsed().as_millis(); + windmill_queue::append_logs( + &job_id, + w_id, + format!( + "\nDone. Time spent on installation phase: {}ms\n", + total_time + ), + conn, + ) + .await; +} diff --git a/backend/windmill-worker/src/windmill-client.js b/backend/windmill-worker/src/windmill-client.js index 1ecf28e664..33e51577e6 100644 --- a/backend/windmill-worker/src/windmill-client.js +++ b/backend/windmill-worker/src/windmill-client.js @@ -2999,6 +2999,7 @@ var $RawScript = { "graphql", "nativets", "duckdb", + "ruby", // for related places search: ADD_NEW_LANG ], }, diff --git a/backend/windmill-worker/src/worker.rs b/backend/windmill-worker/src/worker.rs index 4ff474cbd2..2ed78f0066 100644 --- a/backend/windmill-worker/src/worker.rs +++ b/backend/windmill-worker/src/worker.rs @@ -134,6 +134,9 @@ use crate::nu_executor::{handle_nu_job, JobHandlerInput as JobHandlerInputNu}; #[cfg(feature = "java")] use crate::java_executor::{handle_java_job, JobHandlerInput as JobHandlerInputJava}; +#[cfg(feature = "ruby")] +use crate::ruby_executor::{handle_ruby_job, JobHandlerInput as JobHandlerInputRuby}; + #[cfg(feature = "php")] use crate::php_executor::handle_php_job; @@ -191,10 +194,14 @@ pub const RUST_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "rust"); pub const NU_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "nu"); pub const CSHARP_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "csharp"); -// JAVA +// Java pub const JAVA_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "java"); pub const COURSIER_CACHE_DIR: &str = concatcp!(JAVA_CACHE_DIR, "/coursier-cache"); pub const JAVA_REPOSITORY_DIR: &str = concatcp!(JAVA_CACHE_DIR, "/repository"); + +// Ruby +pub const RUBY_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "ruby"); + // for related places search: ADD_NEW_LANG pub const BUN_CACHE_DIR: &str = concatcp!(ROOT_CACHE_NOMOUNT_DIR, "bun"); pub const BUN_BUNDLE_CACHE_DIR: &str = concatcp!(ROOT_CACHE_DIR, "bun"); @@ -338,6 +345,7 @@ lazy_static::lazy_static! { .ok() .and_then(|x| x.parse::().ok()) .unwrap_or(false)); + pub static ref RUBY_REPOS: Arc>>> = Arc::new(RwLock::new(None)); pub static ref PIP_EXTRA_INDEX_URL: Arc>> = Arc::new(RwLock::new(None)); pub static ref PIP_INDEX_URL: Arc>> = Arc::new(RwLock::new(None)); @@ -3439,6 +3447,33 @@ mount {{ }) .await } + Some(ScriptLang::Ruby) => { + #[cfg(not(feature = "ruby"))] + return Err(anyhow::anyhow!( + "Ruby is not available because the feature is not enabled" + ) + .into()); + + #[cfg(feature = "ruby")] + handle_ruby_job(JobHandlerInputRuby { + mem_peak, + canceled_by, + job, + conn, + client, + parent_runnable_path, + inner_content: &code, + job_dir, + requirements_o: lock.as_ref(), + shared_mount: &shared_mount, + base_internal_url, + worker_name, + envs, + occupancy_metrics, + }) + .await + } + // for related places search: ADD_NEW_LANG _ => panic!("unreachable, language is not supported: {language:#?}"), }; tracing::info!( @@ -3511,6 +3546,10 @@ fn parse_sig_of_lang( ScriptLang::Java => Some(windmill_parser_java::parse_java_signature(code)?), #[cfg(not(feature = "java"))] ScriptLang::Java => None, + #[cfg(feature = "ruby")] + ScriptLang::Ruby => Some(windmill_parser_ruby::parse_ruby_signature(code)?), + #[cfg(not(feature = "ruby"))] + ScriptLang::Ruby => None, // for related places search: ADD_NEW_LANG } } else { diff --git a/backend/windmill-worker/src/worker_lockfiles.rs b/backend/windmill-worker/src/worker_lockfiles.rs index 3d24e424d5..575d94c28c 100644 --- a/backend/windmill-worker/src/worker_lockfiles.rs +++ b/backend/windmill-worker/src/worker_lockfiles.rs @@ -42,7 +42,10 @@ use crate::common::OccupancyMetrics; use crate::csharp_executor::generate_nuget_lockfile; #[cfg(feature = "java")] -use crate::java_executor::resolve; +use crate::java_executor; + +#[cfg(feature = "ruby")] +use crate::ruby_executor; #[cfg(feature = "php")] use crate::php_executor::{composer_install, parse_php_imports}; @@ -2415,7 +2418,7 @@ async fn capture_dependency_job( )); } - resolve( + java_executor::resolve( job_id, job_raw_code, job_dir, @@ -2424,6 +2427,26 @@ async fn capture_dependency_job( ) .await } + #[cfg(feature = "ruby")] + ScriptLang::Ruby => { + if raw_deps { + return Err(Error::ExecutionErr( + "Raw dependencies not supported for Ruby".to_string(), + )); + } + + ruby_executor::resolve( + job_id, + job_raw_code, + mem_peak, + canceled_by, + job_dir, + &Connection::Sql(db.clone()), + worker_name, + w_id, + ) + .await + } // for related places search: ADD_NEW_LANG _ => Ok("".to_owned()), } diff --git a/cli/bootstrap/script_bootstrap.ts b/cli/bootstrap/script_bootstrap.ts index e9e8a12db5..5335e1741c 100644 --- a/cli/bootstrap/script_bootstrap.ts +++ b/cli/bootstrap/script_bootstrap.ts @@ -126,6 +126,11 @@ public class Main { System.out.println("Hello World"); } } +`, + ruby: ` +def main a, b, c + puts a, b, c +end `, // for related places search: ADD_NEW_LANG }; diff --git a/cli/dnt.ts b/cli/dnt.ts index ac99fc1c4a..9f576a3a2c 100644 --- a/cli/dnt.ts +++ b/cli/dnt.ts @@ -71,6 +71,8 @@ await build({ "yaml", "csharp", "java", + "ruby", + // for related places search: ADD_NEW_LANG ]; for (const l of dirs) { diff --git a/cli/src/commands/script/script.ts b/cli/src/commands/script/script.ts index 2becb662e4..a2240498ab 100644 --- a/cli/src/commands/script/script.ts +++ b/cli/src/commands/script/script.ts @@ -578,7 +578,9 @@ export function filePathExtensionFromContentType( return ".nu"; } else if (language === "java") { return ".java"; - // for related places search: ADD_NEW_LANG + } else if (language === "ruby") { + return ".rb"; + // for related places search: ADD_NEW_LANG } else { throw new Error("Invalid language: " + language); } @@ -608,7 +610,8 @@ export const exts = [ ".nu", ".playbook.yml", ".java", - // for related places search: ADD_NEW_LANG + ".rb" + // for related places search: ADD_NEW_LANG ]; export function removeExtensionToPath(path: string): string { diff --git a/cli/src/commands/sync/sync.ts b/cli/src/commands/sync/sync.ts index ee5c6a965c..c17861a497 100644 --- a/cli/src/commands/sync/sync.ts +++ b/cli/src/commands/sync/sync.ts @@ -694,7 +694,8 @@ export async function elementsToMap( "yml", "nu", "java", - // for related places search: ADD_NEW_LANG + "rb", + // for related places search: ADD_NEW_LANG ].includes(path.split(".").pop() ?? "") && !isFileResource(path) ) diff --git a/cli/src/types.ts b/cli/src/types.ts index e74d302a42..57c1c9b8e7 100644 --- a/cli/src/types.ts +++ b/cli/src/types.ts @@ -232,6 +232,7 @@ export function getTypeStrFromPath( parsed.ext == ".cs" || parsed.ext == ".nu" || parsed.ext == ".java" || + parsed.ext == ".rb" || // for related places search: ADD_NEW_LANG (parsed.ext == ".yml" && parsed.name.split(".").pop() == "playbook") ) { diff --git a/cli/src/utils/metadata.ts b/cli/src/utils/metadata.ts index cb5de7391a..d153fcbd8f 100644 --- a/cli/src/utils/metadata.ts +++ b/cli/src/utils/metadata.ts @@ -643,7 +643,10 @@ export async function inferSchema( } else if (language === "java") { const { parse_java } = await import("../../wasm/java/windmill_parser_wasm.js"); inferedSchema = JSON.parse(parse_java(content)); - // for related places search: ADD_NEW_LANG + } else if (language === "ruby") { + const { parse_ruby } = await import("./wasm/ruby/windmill_parser_wasm.js"); + inferedSchema = JSON.parse(parse_ruby(content)); + // for related places search: ADD_NEW_LANG } else { throw new Error("Invalid language: " + language); } diff --git a/cli/src/utils/script_common.ts b/cli/src/utils/script_common.ts index 85efea9786..df661d25fe 100644 --- a/cli/src/utils/script_common.ts +++ b/cli/src/utils/script_common.ts @@ -19,6 +19,7 @@ export type ScriptLanguage = | "csharp" | "nu" | "ansible" + | "ruby" | "java"; // for related places search: ADD_NEW_LANG @@ -87,7 +88,9 @@ export function inferContentTypeFromFilePath( return "nu"; } else if (contentPath.endsWith(".java")) { return "java"; - // for related places search: ADD_NEW_LANG + } else if (contentPath.endsWith(".rb")) { + return "ruby"; + // for related places search: ADD_NEW_LANG } else { throw new Error( "Invalid language: " + contentPath.substring(contentPath.lastIndexOf(".")) diff --git a/cli/wasm/ruby/windmill_parser_wasm.d.ts b/cli/wasm/ruby/windmill_parser_wasm.d.ts new file mode 100644 index 0000000000..1d3229c2ec --- /dev/null +++ b/cli/wasm/ruby/windmill_parser_wasm.d.ts @@ -0,0 +1,3 @@ +/* tslint:disable */ +/* eslint-disable */ +export function parse_ruby(code: string): string; diff --git a/cli/wasm/ruby/windmill_parser_wasm.js b/cli/wasm/ruby/windmill_parser_wasm.js new file mode 100644 index 0000000000..2c44b756b6 --- /dev/null +++ b/cli/wasm/ruby/windmill_parser_wasm.js @@ -0,0 +1,121 @@ + + +let WASM_VECTOR_LEN = 0; + +let cachedUint8ArrayMemory0 = null; + +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } ); + +const encodeString = function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +}; + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } ); + +if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }; + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} +/** + * @param {string} code + * @returns {string} + */ +export function parse_ruby(code) { + let deferred2_0; + let deferred2_1; + try { + const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.parse_ruby(ptr0, len0); + deferred2_0 = ret[0]; + deferred2_1 = ret[1]; + return getStringFromWasm0(ret[0], ret[1]); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +const imports = { + __wbindgen_placeholder__: { + __wbindgen_init_externref_table: function() { + const table = wasm.__wbindgen_export_0; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + ; + }, + }, + +}; + +const wasm_url = new URL('windmill_parser_wasm_bg.wasm', import.meta.url); +let wasmCode = ''; +switch (wasm_url.protocol) { + case 'file:': + wasmCode = await Deno.readFile(wasm_url); + break + case 'https:': + case 'http:': + wasmCode = await (await fetch(wasm_url)).arrayBuffer(); + break + default: + throw new Error(`Unsupported protocol: ${wasm_url.protocol}`); +} + +const wasmInstance = (await WebAssembly.instantiate(wasmCode, imports)).instance; +const wasm = wasmInstance.exports; +export const __wasm = wasm; + +wasm.__wbindgen_start(); + diff --git a/cli/wasm/ruby/windmill_parser_wasm_bg.wasm b/cli/wasm/ruby/windmill_parser_wasm_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..e71dce2e5cda3c27c99271b0125dc02c1808c18d GIT binary patch literal 1853693 zcmeFa4VYX-l|Fv!cK1xrOwXkA!4Q%Fx0|Q~CJ+@v45+y*5D*aDb$8iaRzQiuBw`XG z;x0=D2pAPLB5G9Bh$yI_5m8YQBk~b7Xi!j8#DJ)%sEDYjeEi<`RMoAz)wid6CT{-E z|9Lj(^u2XXojP^SsZ*yuZ*lIFP?Atb~k-KX=N zdoDmoVDj2?@wc>=DP{a+`RZKq&;K2wW}bA?>t25P8K=H#*%>FTTye@PmYw#R6{jv+ zebPyLdw|o=IDO4Y%g$c2Z1owdm%Z|&HK)9M#j>cs^tbpgu~L;%c}hGmO;ySzg@3&e zQ(UQ(RIJLXw-l9C9QD+vm&@f!WlE_ON0riyN?%;5mMWzv%NyA2~D>WNf|<&?@jY9Jnf9_p1+MMWrKcR=`Wkbimxt9>e}p!7g}y6@CF`0BLWnE%jG?K`%q{U^#F$QB9JMSW`Rt(0tRCRc7^Gf zg~s4k7gJH?GTwVsd5~qO{@KjZQ|hlqJ!J*4pjum4ACdhW`Yr zDwU`Lu?cORF050wLy*!yyi$D`|Gg#}1FtGt(9;JSOvlEyL<7AaEH!#wz3kPmS^fGr z>R)-v>NA&}wEDF#e|_}vxcti1%a%oVsmduYf6eMO(L3XwSD&(C#cN&>-L86Gp`X5_ zdRH&gkFV=JbIs~AUh(Rc(Vr9vzT&ji(G#i%iG2FAs-Ax4>&{#Wvx#n$=Tlak@!D5M zzmVrsPk+_vYoZ-7abCM}<+9b$ee!(Dij}9G5`9~qSG?wRNWVX>yaFsNkKPsco_^-a z)u*4aCi-dI`$~CwW%TB_^2(L3U2|siZvF6zXk*;-%2Qvna@iTtd+>z3XD*B0i>KGE zK7Gxy=zVeDS!bSMGG81I3hk3#wQS9r(_g(Tx-70{!1u?4C!KW4nP)Crz2>A>o^tw% z=mYU|&+eC7L`q7~Stc#4-QvfiQUUecLsPJ!5?zTd_wO4Yy( z>aq9->JRG8>Sytdc>0yPQ2jjK7H>DtUx}Y}g?cc)AYOLP9r5k)cj8Oq+ti!Xk$+Xc zjK3S-8UHGNQ~c}rBk|wV#pgdZZ!%9;Bkkkr0ku8;BvSsU-lBdN|IdGXS6v%_CjM;vxcXlFaQq$h4fSsI zdG$wdb(i{qdPu!N{XYI$Jf<#FpE2)Wj&F{?r*4h!h;LS#f%ko+|5mM6KUcTJ*Qqh} zesvpQ-;Mtme=UYQv5^Yy&)#;Z^&O2|2h7$>OF1VFV&e3st4i^#s7Y%dV75Cr{izN ze^Eb*7p;%ak1vXArStAk{onljw7XT9$1*Z
O<;s^8*Q5BYHgzoM>DpM;m$tUj%-g+IGaeO7%A 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

p8$ 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 wYekdIpvJxeB3x`!>qIN2W9Q(=UDn28Rhnn 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 [number, number]; +export const free: (a: number) => void; +export const abort: () => void; +export const malloc: (a: number) => number; +export const calloc: (a: number, b: number) => number; +export const realloc: (a: number, b: number) => number; +export const strncmp: (a: number, b: number, c: number) => number; +export const memchr: (a: number, b: number, c: number) => number; +export const strchr: (a: number, b: number) => number; +export const iswspace: (a: number) => number; +export const iswalnum: (a: number) => number; +export const iswdigit: (a: number) => number; +export const iswupper: (a: number) => number; +export const iswalpha: (a: number) => number; +export const iswlower: (a: number) => number; +export const clock: () => bigint; +export const isprint: (a: number) => number; +export const fprintf: (a: number, b: number, c: number) => number; +export const fputs: (a: number, b: number) => number; +export const fputc: (a: number, b: number) => number; +export const fdopen: (a: number, b: number) => number; +export const fclose: (a: number) => number; +export const fwrite: (a: number, b: number, c: number, d: number) => number; +export const vsnprintf: (a: number, b: number, c: number, d: number) => number; +export const clock_gettime: (a: number, b: number) => void; +export const snprintf: () => void; +export const __assert_fail: (a: number, b: number, c: number, d: number) => void; +export const __wbindgen_export_0: WebAssembly.Table; +export const __wbindgen_malloc: (a: number, b: number) => number; +export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; +export const __wbindgen_free: (a: number, b: number, c: number) => void; +export const __wbindgen_start: () => void; diff --git a/docker/DockerfileFull b/docker/DockerfileFull index 6efb16c7bd..1d5f639113 100644 --- a/docker/DockerfileFull +++ b/docker/DockerfileFull @@ -22,3 +22,6 @@ RUN curl -fLo coursier https://github.com/coursier/coursier/releases/download/v2 && mv ./coursier /usr/bin/coursier \ && chmod +x /usr/bin/coursier RUN /usr/bin/java -jar /usr/bin/coursier about + +# Ruby +RUN apt-get install -y ruby ruby-bundler diff --git a/docker/DockerfileFullEe b/docker/DockerfileFullEe index e93aaaf9a0..376f994f89 100644 --- a/docker/DockerfileFullEe +++ b/docker/DockerfileFullEe @@ -45,3 +45,6 @@ RUN curl -fLo coursier https://github.com/coursier/coursier/releases/download/v2 && mv ./coursier /usr/bin/coursier \ && chmod +x /usr/bin/coursier RUN /usr/bin/java -jar /usr/bin/coursier about + +# Ruby +RUN apt-get install -y ruby ruby-bundler diff --git a/docker/DockerfileNsjail b/docker/DockerfileNsjail index 2e9b0b0580..a995c76fac 100644 --- a/docker/DockerfileNsjail +++ b/docker/DockerfileNsjail @@ -70,6 +70,9 @@ RUN curl -fLo coursier https://github.com/coursier/coursier/releases/download/v2 && chmod +x /usr/bin/coursier RUN /usr/bin/java -jar /usr/bin/coursier about +# Ruby +RUN apt-get install -y ruby ruby-bundler + # iptables RUN apt-get install -y iptables diff --git a/docker/dev.nu b/docker/dev.nu index a1fd303b0b..77d2641204 100755 --- a/docker/dev.nu +++ b/docker/dev.nu @@ -4,6 +4,8 @@ # run: # # docker/dev.nu --help # # ------------------------------------ # +# NOTE: +# Does not work if built from git worktree branch let branch = git branch --show-current; # cp -f Caddyfile .dev-docker/Caddyfile @@ -57,6 +59,7 @@ def patch_custom_dockerfile [ ] { open $custom_dockerfile | str replace 'ghcr.io/windmill-labs/windmill-ee:dev' (get_ident -f $features) + | str replace 'ghcr.io/windmill-labs/windmill:dev' (get_ident -f $features) | return $in } diff --git a/flake.nix b/flake.nix index 9aac3a3664..be958fd547 100644 --- a/flake.nix +++ b/flake.nix @@ -143,6 +143,7 @@ dotnet-sdk_9 oracle-instantclient ansible + ruby_3_4 # LSP/Local dev svelte-language-server @@ -214,7 +215,10 @@ GIT_PATH = "${pkgs.git}/bin/git"; NODE_ENV = "development"; NODE_OPTIONS = "--max-old-space-size=16384"; - DATABASE_URL = "postgres://postgres:changeme@127.0.0.1:5432/"; + # DATABASE_URL = "postgres://postgres:changeme@127.0.0.1:5432/"; + DATABASE_URL = + "postgres://postgres:changeme@127.0.0.1:5432/windmill?sslmode=disable"; + REMOTE = "http://127.0.0.1:8000"; REMOTE_LSP = "http://127.0.0.1:3001"; RUSTC_WRAPPER = "${pkgs.sccache}/bin/sccache"; @@ -228,7 +232,10 @@ JAVA_PATH = "${pkgs.jdk21}/bin/java"; JAVAC_PATH = "${pkgs.jdk21}/bin/javac"; COURSIER_PATH = "${coursier}/coursier"; - # for related places search: ADD_NEW_LANG + RUBY_PATH = "${pkgs.ruby}/bin/ruby"; + RUBY_BUNDLE_PATH = "${pkgs.ruby}/bin/bundle"; + RUBY_GEM_PATH = "${pkgs.ruby}/bin/gem"; + # for related places search: ADD_NEW_LANG FLOCK_PATH = "${pkgs.flock}/bin/flock"; CARGO_PATH = "${rust}/bin/cargo"; CARGO_SWEEP_PATH = "${pkgs.cargo-sweep}/bin/cargo-sweep"; diff --git a/frontend/package-lock.json b/frontend/package-lock.json index eb37230be8..324bc799da 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -81,6 +81,7 @@ "windmill-parser-wasm-php": "1.510.1", "windmill-parser-wasm-py": "1.510.1", "windmill-parser-wasm-regex": "1.512.0", + "windmill-parser-wasm-ruby": "1.526.1", "windmill-parser-wasm-rust": "1.510.1", "windmill-parser-wasm-ts": "1.514.1", "windmill-parser-wasm-yaml": "1.510.1", @@ -156,6 +157,11 @@ "svelte": "^5.0.0" } }, + "../backend/parsers/windmill-parser-wasm/pkg-ruby": { + "name": "windmill-parser-wasm-ruby", + "version": "1.510.0", + "extraneous": true + }, "node_modules/@alloc/quick-lru": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", @@ -13144,6 +13150,11 @@ "resolved": "https://registry.npmjs.org/windmill-parser-wasm-regex/-/windmill-parser-wasm-regex-1.512.0.tgz", "integrity": "sha512-mOkuspfjPPhGZwmerBlFOjRKHjycrlzZUpxO7gHy5D6kwKI2bSz+VI3TsJqmK1y9PwAGgO8JnwRmNAR/YLUkzA==" }, + "node_modules/windmill-parser-wasm-ruby": { + "version": "1.526.1", + "resolved": "https://registry.npmjs.org/windmill-parser-wasm-ruby/-/windmill-parser-wasm-ruby-1.526.1.tgz", + "integrity": "sha512-rMBQA8s21wmL2kA5ztRs/ZgVA3ckxe9/NLjxl3iQPL0CX6DlvfaUH0O+AnhpXXDMyBs1Y1SZIhcnbnvsHZ3R8g==" + }, "node_modules/windmill-parser-wasm-rust": { "version": "1.510.1", "resolved": "https://registry.npmjs.org/windmill-parser-wasm-rust/-/windmill-parser-wasm-rust-1.510.1.tgz", diff --git a/frontend/package.json b/frontend/package.json index fdbfaab967..24e60adeb5 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -148,6 +148,7 @@ "windmill-parser-wasm-php": "1.510.1", "windmill-parser-wasm-py": "1.510.1", "windmill-parser-wasm-regex": "1.512.0", + "windmill-parser-wasm-ruby": "1.526.1", "windmill-parser-wasm-rust": "1.510.1", "windmill-parser-wasm-ts": "1.514.1", "windmill-parser-wasm-yaml": "1.510.1", @@ -543,4 +544,4 @@ "@rollup/rollup-linux-x64-gnu": "^4.35.0", "fsevents": "^2.3.3" } -} +} \ No newline at end of file diff --git a/frontend/src/lib/components/Editor.svelte b/frontend/src/lib/components/Editor.svelte index f87322d76f..825b6f7f58 100644 --- a/frontend/src/lib/components/Editor.svelte +++ b/frontend/src/lib/components/Editor.svelte @@ -160,7 +160,6 @@ let editor: meditor.IStandaloneCodeEditor | null = $state(null) interface Props { - // for related places search: ADD_NEW_LANG code?: string cmdEnterAction?: (() => void) | undefined formatAction?: (() => void) | undefined diff --git a/frontend/src/lib/components/EditorBar.svelte b/frontend/src/lib/components/EditorBar.svelte index 00b92bff41..40665e3f36 100644 --- a/frontend/src/lib/components/EditorBar.svelte +++ b/frontend/src/lib/components/EditorBar.svelte @@ -132,7 +132,8 @@ 'rust', 'csharp', 'nu', - 'java' + 'java', + 'ruby' // for related places search: ADD_NEW_LANG ].includes(lang ?? '') ) @@ -151,7 +152,8 @@ 'rust', 'csharp', 'nu', - 'java' + 'java', + 'ruby' // for related places search: ADD_NEW_LANG ].includes(lang ?? '') ) @@ -170,7 +172,8 @@ 'rust', 'csharp', 'nu', - 'java' + 'java', + 'ruby', // for related places search: ADD_NEW_LANG ].includes(lang ?? '') ) @@ -436,6 +439,8 @@ } else if (lang == 'java') { editor.insertAtCursor(`System.getenv("${name}");`) // for related places search: ADD_NEW_LANG + } else if (lang == 'ruby') { + editor.insertAtCursor(`ENV['${name}']`) } sendUserToast(`${name} inserted at cursor`) }} @@ -506,6 +511,11 @@ string ${windmillPathToCamelCaseName(path)} = await client.GetStringAsync(uri); } else if (lang == 'java') { editor.insertAtCursor(`(Wmill.getVariable("${path}"))`) // for related places search: ADD_NEW_LANG + } else if (lang == 'ruby') { + if (!editor.getCode().includes("require 'windmill/mini'")) { + editor.insertAtBeginning("require 'windmill/mini'\n") + } + editor.insertAtCursor(`get_variable("${path}")`) } sendUserToast(`${name} inserted at cursor`) }} @@ -595,6 +605,11 @@ JsonNode ${windmillPathToCamelCaseName(path)} = JsonNode.Parse(await client.GetS } else if (lang == 'java') { editor.insertAtCursor(`(Wmill.getResource("${path}"))`) // for related places search: ADD_NEW_LANG + } else if (lang == 'ruby') { + if (!editor.getCode().includes("require 'windmill/mini'")) { + editor.insertAtBeginning("require 'windmill/mini'\n") + } + editor.insertAtCursor(`get_resource("${path}")`) } else if (lang == 'duckdb') { let t = { postgresql: 'postgres', mysql: 'mysql', bigquery: 'bigquery' }[resType] if (!t) { diff --git a/frontend/src/lib/components/HighlightCode.svelte b/frontend/src/lib/components/HighlightCode.svelte index bf196c7868..aebd2bf0f1 100644 --- a/frontend/src/lib/components/HighlightCode.svelte +++ b/frontend/src/lib/components/HighlightCode.svelte @@ -13,6 +13,7 @@ import csharp from 'svelte-highlight/languages/csharp' import yaml from 'svelte-highlight/languages/yaml' import java from 'svelte-highlight/languages/java' + import ruby from 'svelte-highlight/languages/ruby' import type { Script } from '$lib/gen' import { Button } from './common' import { copyToClipboard } from '$lib/utils' @@ -70,8 +71,10 @@ case 'ansible': return yaml case 'java': - return java - // for related places search: ADD_NEW_LANG + return java; + case 'ruby': + return ruby; + // for related places search: ADD_NEW_LANG default: return typescript } diff --git a/frontend/src/lib/components/ScriptBuilder.svelte b/frontend/src/lib/components/ScriptBuilder.svelte index 28d54fd01d..7d1721a988 100644 --- a/frontend/src/lib/components/ScriptBuilder.svelte +++ b/frontend/src/lib/components/ScriptBuilder.svelte @@ -1128,7 +1128,7 @@ > {label} - {#if lang === 'nu'} + {#if lang === 'nu' || lang === 'ruby'} BETA {/if} diff --git a/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte b/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte index 3cfb57fee5..19c8a5e991 100644 --- a/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte +++ b/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte @@ -23,6 +23,7 @@ import NuIcon from '$lib/components/icons/NuIcon.svelte' import JavaIcon from '$lib/components/icons/JavaIcon.svelte' import DuckDbIcon from '$lib/components/icons/DuckDbIcon.svelte' + import RubyIcon from '$lib/components/icons/RubyIcon.svelte' interface Props { lang: @@ -71,8 +72,9 @@ ansible: 'Ansible', csharp: 'C#', nu: 'Nu', - java: 'Java' - // for related places search: ADD_NEW_LANG + java: 'Java', + ruby: 'Ruby' + // for related places search: ADD_NEW_LANG } const langToComponent: Record< @@ -105,6 +107,7 @@ csharp: CSharpIcon, nu: NuIcon, java: JavaIcon, + ruby: RubyIcon, duckdb: DuckDbIcon // for related places search: ADD_NEW_LANG } diff --git a/frontend/src/lib/components/icons/RubyIcon.svelte b/frontend/src/lib/components/icons/RubyIcon.svelte new file mode 100644 index 0000000000..307fde1a3d --- /dev/null +++ b/frontend/src/lib/components/icons/RubyIcon.svelte @@ -0,0 +1,661 @@ + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/frontend/src/lib/components/instanceSettings.ts b/frontend/src/lib/components/instanceSettings.ts index 1a873d532f..9bf4b6bad6 100644 --- a/frontend/src/lib/components/instanceSettings.ts +++ b/frontend/src/lib/components/instanceSettings.ts @@ -331,6 +331,15 @@ export const settings: Record = { fieldType: 'boolean', storage: 'setting', ee_only: '' + }, + { + label: 'Ruby Gems repositories', + description: 'Add private Ruby repositories with credentials. Should end with /', + key: 'ruby_repos', + fieldType: 'text', + placeholder: 'https://user:password@gems.foo.com/', + storage: 'setting', + ee_only: '' } ], Alerts: [ diff --git a/frontend/src/lib/components/worker_group.ts b/frontend/src/lib/components/worker_group.ts index 70277da84e..a396568836 100644 --- a/frontend/src/lib/components/worker_group.ts +++ b/frontend/src/lib/components/worker_group.ts @@ -53,8 +53,10 @@ export const defaultTags = [ 'ansible', 'csharp', 'nu', - 'java' - // KJQXZ + 'java', + 'ruby' + // for related places search: ADD_NEW_LANG + ] export const nativeTags = [ 'nativets', @@ -65,4 +67,4 @@ export const nativeTags = [ 'mssql', 'bigquery', 'oracledb' -] \ No newline at end of file +] diff --git a/frontend/src/lib/editorLangUtils.ts b/frontend/src/lib/editorLangUtils.ts index 17d75afe16..c856d1bd8b 100644 --- a/frontend/src/lib/editorLangUtils.ts +++ b/frontend/src/lib/editorLangUtils.ts @@ -97,6 +97,8 @@ export function extToLang(ext: string) { return 'nu' case 'java': return 'java' + case 'rb': + return 'ruby' // for related places search: ADD_NEW_LANG default: return 'unknown' diff --git a/frontend/src/lib/editorUtils.ts b/frontend/src/lib/editorUtils.ts index 5c86f53a60..4cb3b586ed 100644 --- a/frontend/src/lib/editorUtils.ts +++ b/frontend/src/lib/editorUtils.ts @@ -41,8 +41,6 @@ export function editorConfig( } } - - export const updateOptions = { tabSize: 2, insertSpaces: true } export function convertKind(kind: string): any { diff --git a/frontend/src/lib/infer.ts b/frontend/src/lib/infer.ts index 702d8c7265..dbe75e6beb 100644 --- a/frontend/src/lib/infer.ts +++ b/frontend/src/lib/infer.ts @@ -27,6 +27,7 @@ import initYamlParser, { parse_ansible } from 'windmill-parser-wasm-yaml' import initCSharpParser, { parse_csharp } from 'windmill-parser-wasm-csharp' import initNuParser, { parse_nu } from 'windmill-parser-wasm-nu' import initJavaParser, { parse_java } from 'windmill-parser-wasm-java' +import initRubyParser, { parse_ruby } from 'windmill-parser-wasm-ruby' import wasmUrlTs from 'windmill-parser-wasm-ts/windmill_parser_wasm_bg.wasm?url' import wasmUrlRegex from 'windmill-parser-wasm-regex/windmill_parser_wasm_bg.wasm?url' @@ -38,6 +39,7 @@ import wasmUrlYaml from 'windmill-parser-wasm-yaml/windmill_parser_wasm_bg.wasm? import wasmUrlCSharp from 'windmill-parser-wasm-csharp/windmill_parser_wasm_bg.wasm?url' import wasmUrlNu from 'windmill-parser-wasm-nu/windmill_parser_wasm_bg.wasm?url' import wasmUrlJava from 'windmill-parser-wasm-java/windmill_parser_wasm_bg.wasm?url' +import wasmUrlRuby from 'windmill-parser-wasm-ruby/windmill_parser_wasm_bg.wasm?url' import { workspaceStore } from './stores.js' import { argSigToJsonSchemaType } from 'windmill-utils-internal' import { type AssetWithAccessType } from './components/assets/lib.js' @@ -79,6 +81,9 @@ async function initWasmNu() { async function initWasmJava() { await initJavaParser(wasmUrlJava) } +async function initWasmRuby() { + await initRubyParser(wasmUrlRuby) +} export async function inferAssets( language: SupportedLanguage | undefined, @@ -241,7 +246,10 @@ export async function inferArgs( } else if (language == 'java') { await initWasmJava() inferedSchema = JSON.parse(parse_java(code)) - // for related places search: ADD_NEW_LANG + } else if (language == 'ruby') { + await initWasmRuby() + inferedSchema = JSON.parse(parse_ruby(code)) + // for related places search: ADD_NEW_LANG } else { return null } diff --git a/frontend/src/lib/script_helpers.ts b/frontend/src/lib/script_helpers.ts index 7b0797d595..7c02bd6aea 100644 --- a/frontend/src/lib/script_helpers.ts +++ b/frontend/src/lib/script_helpers.ts @@ -1107,6 +1107,55 @@ public class Main { } } ` +const RUBY_INIT_CODE = `require 'windmill/inline' +require 'windmill/mini' + +# Dependency management: declare gems in gemfile block for automatic installation +# Windmill uses bundler/inline compatible syntax with automatic requiring +gemfile do + source 'https://rubygems.org' + gem 'amazing_print', '~> 1.6' +end + +def main( + no_default, + name = "Nicolas Bourbaki", + age = 42, + obj = { "even": "hashes" }, + list = ["or", "arrays!"] +) + puts "Hello World and a warm welcome especially to #{name}" + puts "and its acolytes.. #{age} #{obj} #{list}" + + # Retrieve variables using the Windmill mini client + begin + secret = get_variable("f/examples/secret") + rescue => e + secret = "No secret yet at f/examples/secret!" + end + puts "The variable at 'f/examples/secret': #{secret}" + + # Get typed resources using the mini client + # database = get_resource("u/user/my_postgresql") + + # Access environment variables provided by Windmill + user = ENV['WM_USERNAME'] + + # Pretty print results using amazing_print (automatically required from gemfile) + result = { + "splitted" => name.split, + "user" => user, + "age" => age, + "obj" => obj, + "list" => list + } + + ap result + + # Return value is automatically converted to JSON + return result +end +` // for related places search: ADD_NEW_LANG export const INITIAL_CODE = { bun: { @@ -1197,8 +1246,11 @@ export const INITIAL_CODE = { }, java: { script: JAVA_INIT_CODE - } - // for related places search: ADD_NEW_LANG + }, + ruby: { + script: RUBY_INIT_CODE + }, + // for related places search: ADD_NEW_LANG } export function isInitialCode(content: string): boolean { @@ -1306,7 +1358,9 @@ export function initialCode( return INITIAL_CODE.nu.script } else if (language == 'java') { return INITIAL_CODE.java.script - // for related places search: ADD_NEW_LANG + } else if (language == 'ruby') { + return INITIAL_CODE.ruby.script + // for related places search: ADD_NEW_LANG } else if (language == 'bun' || language == 'bunnative') { if (kind == 'trigger') { return INITIAL_CODE.bun.trigger diff --git a/frontend/src/lib/scripts.ts b/frontend/src/lib/scripts.ts index 961ae72488..50884f3c26 100644 --- a/frontend/src/lib/scripts.ts +++ b/frontend/src/lib/scripts.ts @@ -143,7 +143,8 @@ const scriptLanguagesArray: [SupportedLanguage | 'docker' | 'bunnative', string] ['docker', 'Docker'], ['nu', 'Nu'], ['java', 'Java'], - ['duckdb', 'DuckDB'] + ['duckdb', 'DuckDB'], + ['ruby', 'Ruby'] // for related places search: ADD_NEW_LANG ] export function processLangs(selected: string | undefined, langs: string[]): string[] { @@ -153,7 +154,7 @@ export function processLangs(selected: string | undefined, langs: string[]): str let ls = langs.filter((lang) => lang !== 'nativets') //those languages are newer and may not be in the saved list - let nl = ['bunnative', 'rust', 'ansible', 'csharp', 'nu', 'java', 'duckdb'] + let nl = ['bunnative', 'rust', 'ansible', 'csharp', 'nu', 'java', 'duckdb', 'ruby'] // for related places search: ADD_NEW_LANG nl.forEach((lang) => { if (!ls.includes(lang)) { diff --git a/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte b/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte index 26ccaea24e..8daa4d4f2a 100644 --- a/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte +++ b/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte @@ -791,7 +791,7 @@ priority: {job.priority} {/if} - {#if job.tag && !['deno', 'python3', 'flow', 'other', 'go', 'postgresql', 'mysql', 'bigquery', 'snowflake', 'mssql', 'graphql', 'oracledb', 'nativets', 'bash', 'powershell', 'php', 'rust', 'other', 'ansible', 'csharp', 'nu', 'java', 'duckdb', 'dependency'].includes(job.tag)} + {#if job.tag && !['deno', 'python3', 'flow', 'other', 'go', 'postgresql', 'mysql', 'bigquery', 'snowflake', 'mssql', 'graphql', 'oracledb', 'nativets', 'bash', 'powershell', 'php', 'rust', 'other', 'ansible', 'csharp', 'nu', 'java', 'duckdb', 'dependency', 'ruby'].includes(job.tag)}