feat(worker): support workers to run natively on windows

backend/windmill-api/src/jobs.rs

@@ -4644,8 +4644,8 @@ async fn get_job_update(
     .fetch_optional(&db)
     .await?;
 
-    let progress: Option<i32> = if get_progress == Some(true){
-         sqlx::query_scalar!(
+    let progress: Option<i32> = if get_progress == Some(true) {
+        sqlx::query_scalar!(
                 "SELECT scalar_int FROM job_stats WHERE workspace_id = $1 AND job_id = $2 AND metric_id = $3",
                 &w_id,
                  job_id,

backend/windmill-api/src/resources.rs

@@ -58,7 +58,10 @@ pub fn workspaced_service() -> Router {
         .route("/type/exists/:name", get(exists_resource_type))
         .route("/type/update/:name", post(update_resource_type))
         .route("/type/delete/:name", delete(delete_resource_type))
-        .route("/file_resource_type_to_file_ext_map", get(file_resource_ext_to_resource_type))
+        .route(
+            "/file_resource_type_to_file_ext_map",
+            get(file_resource_ext_to_resource_type),
+        )
         .route("/type/create", post(create_resource_type))
 }
 

backend/windmill-common/src/worker.rs

@@ -195,7 +195,11 @@ fn normalize_path(path: &Path) -> PathBuf {
     }
     ret
 }
-pub fn write_file_at_user_defined_location(job_dir: &str, user_defined_path: &str, content: &str) -> error::Result<File> {
+pub fn write_file_at_user_defined_location(
+    job_dir: &str,
+    user_defined_path: &str,
+    content: &str,
+) -> error::Result<File> {
     let job_dir = Path::new(job_dir);
     let user_path = PathBuf::from(user_defined_path);
 
@@ -210,7 +214,8 @@ pub fn write_file_at_user_defined_location(job_dir: &str, user_defined_path: &st
         return Err(std::io::Error::new(
             std::io::ErrorKind::PermissionDenied,
             "Path is outside the allowed job directory.",
-        ).into());
+        )
+        .into());
     }
 
     if let Some(parent_dir) = full_path.parent() {

backend/windmill-indexer/src/indexer_ee.rs

@@ -1,6 +1,6 @@
+use anyhow::anyhow;
 use sqlx::{Pool, Postgres};
 use windmill_common::error::Error;
-use anyhow::anyhow;
 
 #[derive(Clone)]
 pub struct IndexReader;

backend/windmill-worker/src/ansible_executor.rs

@@ -14,8 +14,8 @@ use windmill_queue::{append_logs, CanceledBy};
 
 use crate::{
     common::{
-        get_reserved_variables, handle_child, read_and_check_result,
-        start_child_process, transform_json,
+        get_reserved_variables, handle_child, read_and_check_result, start_child_process,
+        transform_json,
     },
     python_executor::{create_dependencies_dir, handle_python_reqs, pip_compile},
     AuthedClientBackgroundTask, DISABLE_NSJAIL, HOME_ENV, PATH_ENV, TZ_ENV,

backend/windmill-worker/src/bash_executor.rs

@@ -28,7 +28,7 @@ use crate::{
         start_child_process,
     },
     AuthedClientBackgroundTask, DISABLE_NSJAIL, DISABLE_NUSER, HOME_ENV, NSJAIL_PATH, PATH_ENV,
-    POWERSHELL_CACHE_DIR, POWERSHELL_PATH, TZ_ENV,
+    POWERSHELL_CACHE_DIR, POWERSHELL_PATH, SYSTEM_ROOT, TZ_ENV,
 };
 
 lazy_static::lazy_static! {
@@ -195,7 +195,7 @@ pub async fn handle_powershell_job(
     worker_name: &str,
     envs: HashMap<String, String>,
 ) -> Result<Box<RawValue>, Error> {
-    let pwsh_args = {
+    let mut pwsh_args = {
         let args = build_args_map(job, client, db).await?.map(Json);
         let job_args = if args.is_some() {
             args.as_ref()
@@ -222,13 +222,19 @@ pub async fn handle_powershell_job(
             .collect::<Vec<_>>()
     };
 
+    #[cfg(windows)]
+    let split_char = '\\';
+
+    #[cfg(unix)]
+    let split_char = '/';
+
     let installed_modules = fs::read_dir(POWERSHELL_CACHE_DIR)?
         .filter_map(|x| {
             x.ok().map(|x| {
                 x.path()
                     .display()
                     .to_string()
-                    .split('/')
+                    .split(split_char)
                     .last()
                     .unwrap_or_default()
                     .to_lowercase()
@@ -284,6 +290,7 @@ pub async fn handle_powershell_job(
     append_logs(&job.id, &job.workspace_id, logs2, db).await;
 
     // make sure default (only allhostsallusers) modules are loaded, disable autoload (cache can be large to explore especially on cloud) and add /tmp/windmill/cache to PSModulePath
+    #[cfg(unix)]
     let profile = format!(
         "$PSModuleAutoloadingPreference = 'None'
 $PSModulePathBackup = $env:PSModulePath
@@ -292,6 +299,17 @@ Get-Module -ListAvailable | Import-Module
 $env:PSModulePath = \"{}:$PSModulePathBackup\"",
         POWERSHELL_CACHE_DIR
     );
+
+    #[cfg(windows)]
+    let profile = format!(
+        "#$PSModuleAutoloadingPreference = 'None'
+$PSModulePathBackup = $env:PSModulePath
+#$env:PSModulePath = \"C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\Modules;C:\\Program Files\\PowerShell\\7\\Modules\"
+Get-Module -ListAvailable | Import-Module
+$env:PSModulePath = \"{};$PSModulePathBackup\"",
+        POWERSHELL_CACHE_DIR
+    );
+
     // make sure param() is first
     let param_match = windmill_parser_bash::RE_POWERSHELL_PARAM.find(&content);
     let content: String = if let Some(param_match) = param_match {
@@ -307,11 +325,29 @@ $env:PSModulePath = \"{}:$PSModulePathBackup\"",
     };
 
     write_file(job_dir, "main.ps1", content.as_str())?;
+
+    #[cfg(unix)]
     write_file(
         job_dir,
         "wrapper.sh",
         &format!("set -o pipefail\nset -e\nmkfifo bp\ncat bp | tail -1 > ./result2.out &\n{} -F ./main.ps1 \"$@\" 2>&1 | tee bp\nwait $!", POWERSHELL_PATH.as_str()),
     )?;
+
+    #[cfg(windows)]
+    write_file(
+        job_dir,
+        "wrapper.ps1",
+        &format!(
+            " param([string[]]$args)\n\
+    $ErrorActionPreference = 'Stop'\n\
+    $pipe = New-TemporaryFile\n\
+    & \"{}\" -File ./main.ps1 @args 2>&1 | Tee-Object -FilePath $pipe\n\
+    Get-Content -Path $pipe | Select-Object -Last 1 | Set-Content -Path './result2.out'\n\
+    Remove-Item $pipe\n",
+            POWERSHELL_PATH.as_str()
+        ),
+    )?;
+
     let token = client.get_token().await;
     let mut reserved_variables = get_reserved_variables(job, &token, db).await?;
     reserved_variables.insert("RUST_LOG".to_string(), "info".to_string());
@@ -320,6 +356,7 @@ $env:PSModulePath = \"{}:$PSModulePathBackup\"",
     let _ = write_file(job_dir, "result.out", "")?;
     let _ = write_file(job_dir, "result2.out", "")?;
 
+    #[cfg(unix)]
     let child = if !*DISABLE_NSJAIL {
         let _ = write_file(
             job_dir,
@@ -366,6 +403,38 @@ $env:PSModulePath = \"{}:$PSModulePathBackup\"",
             .stderr(Stdio::piped())
             .spawn()?
     };
+
+    #[cfg(windows)]
+    pwsh_args.insert(0, r".\wrapper.ps1".to_string());
+
+    #[cfg(windows)]
+    let child = Command::new(POWERSHELL_PATH.as_str())
+        .current_dir(job_dir)
+        .env_clear()
+        .envs(envs)
+        .envs(reserved_variables)
+        .env("PATH", PATH_ENV.as_str())
+        .env("BASE_INTERNAL_URL", base_internal_url)
+        .env("HOME", HOME_ENV.as_str())
+        .env("SystemRoot", SYSTEM_ROOT.as_str())
+        .env(
+            "TMP",
+            std::env::var("TMP").unwrap_or_else(|_| String::from("/tmp")),
+        )
+        .env(
+            "PATHEXT",
+            ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL",
+        )
+        .args(
+            pwsh_args
+                .into_iter()
+                .map(|arg| arg.replace("--", "-"))
+                .collect::<Vec<String>>(),
+        )
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()?;
+
     handle_child(
         &job.id,
         db,

backend/windmill-worker/src/bun_executor.rs

@@ -19,7 +19,7 @@ use crate::{
     },
     AuthedClientBackgroundTask, BUNFIG_INSTALL_SCOPES, BUN_BUNDLE_CACHE_DIR, BUN_CACHE_DIR,
     BUN_DEPSTAR_CACHE_DIR, BUN_PATH, DISABLE_NSJAIL, DISABLE_NUSER, HOME_ENV, NODE_BIN_PATH,
-    NODE_PATH, NPM_CONFIG_REGISTRY, NPM_PATH, NSJAIL_PATH, PATH_ENV, TZ_ENV,
+    NODE_PATH, NPM_CONFIG_REGISTRY, NPM_PATH, NSJAIL_PATH, PATH_ENV, SYSTEM_ROOT, TZ_ENV,
 };
 
 use tokio::{fs::File, process::Command};
@@ -110,6 +110,9 @@ pub async fn gen_bun_lockfile(
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
 
+        #[cfg(windows)]
+        child_cmd.env("SystemRoot", SYSTEM_ROOT.as_str());
+
         let mut child_process = start_child_process(child_cmd, &*BUN_PATH).await?;
 
         if let Some(db) = db {
@@ -240,6 +243,9 @@ pub async fn install_bun_lockfile(
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
 
+    #[cfg(windows)]
+    child_cmd.env("SystemRoot", SYSTEM_ROOT.as_str());
+
     let mut npm_logs = if npm_mode {
         "NPM mode\n".to_string()
     } else {
@@ -446,6 +452,10 @@ pub async fn generate_wrapper_mjs(
         .args(vec!["run", "node_builder.ts"])
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
+
+    #[cfg(windows)]
+    child.env("SystemRoot", SYSTEM_ROOT.as_str());
+
     let child_process = start_child_process(child, &*BUN_PATH).await?;
     handle_child(
         job_id,
@@ -489,6 +499,10 @@ pub async fn generate_bun_bundle(
         .args(vec!["run", "node_builder.ts"])
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
+
+    #[cfg(windows)]
+    child.env("SystemRoot", SYSTEM_ROOT.as_str());
+
     let mut child_process = start_child_process(child, &*BUN_PATH).await?;
     if let Some(db) = db {
         handle_child(
@@ -710,6 +724,10 @@ async fn compute_bundle_local_and_remote_path(
 
     let hash = windmill_common::utils::calculate_hash(&input_src);
     let local_path = format!("{BUN_BUNDLE_CACHE_DIR}/{hash}");
+
+    #[cfg(windows)]
+    let local_path = local_path.replace("/tmp", r"C:\tmp").replace("/", r"\");
+
     let remote_path = format!("{BUN_BUNDLE_OBJECT_STORE_PREFIX}{hash}");
     (local_path, remote_path)
 }
@@ -802,14 +820,25 @@ pub async fn handle_bun_job(
         ));
     }
 
-    let mut gbuntar_name = None;
+    let mut gbuntar_name: Option<String> = None;
     if has_bundle_cache {
+        #[cfg(unix)]
         let target = format!("{job_dir}/main.js");
+        #[cfg(unix)]
         std::os::unix::fs::symlink(&local_path, &target).map_err(|e| {
             error::Error::ExecutionErr(format!(
                 "could not copy cached binary from {local_path} to {job_dir}/main: {e:?}"
             ))
         })?;
+
+        #[cfg(windows)]
+        let target = format!("{job_dir}\\main.js");
+        #[cfg(windows)]
+        std::os::windows::fs::symlink_dir(&local_path, &target).map_err(|e| {
+            error::Error::ExecutionErr(format!(
+                "could not copy cached binary from {local_path} to {job_dir}\\main: {e:?}"
+            ))
+        })?;
     } else if let Some(codebase) = codebase.as_ref() {
         pull_codebase(&job.workspace_id, codebase, job_dir).await?;
     } else if let Some(reqs) = requirements_o.as_ref() {
@@ -1295,7 +1324,7 @@ try {{
             .stderr(Stdio::piped());
         start_child_process(nsjail_cmd, NSJAIL_PATH.as_str()).await?
     } else {
-        let cmd = if annotation.nodejs_mode {
+        let mut cmd = if annotation.nodejs_mode {
             let script_path = format!("{job_dir}/wrapper.mjs");
 
             let mut bun_cmd = Command::new(&*NODE_BIN_PATH);
@@ -1336,6 +1365,10 @@ try {{
                 .stderr(Stdio::piped());
             bun_cmd
         };
+
+        #[cfg(windows)]
+        cmd.env("SystemRoot", SYSTEM_ROOT.as_str());
+
         start_child_process(
             cmd,
             if annotation.nodejs_mode {

backend/windmill-worker/src/go_executor.rs

@@ -221,12 +221,20 @@ func Run(req Req) (interface{{}}, error){{
         }
     } else {
         let target = format!("{job_dir}/main");
+        #[cfg(unix)]
         std::os::unix::fs::symlink(&bin_path, &target).map_err(|e| {
             Error::ExecutionErr(format!(
                 "could not copy cached binary from {bin_path} to {job_dir}/main: {e:?}"
             ))
         })?;
 
+        #[cfg(windows)]
+        std::os::windows::fs::symlink_dir(&bin_path, &target).map_err(|e| {
+            Error::ExecutionErr(format!(
+                "could not copy cached binary from {bin_path} to {job_dir}/main: {e:?}"
+            ))
+        })?;
+
         create_args_and_out_file(client, job, job_dir, db).await?;
         cache_logs
     };

backend/windmill-worker/src/lib.rs

@@ -5,6 +5,7 @@ mod mssql_executor;
 #[cfg(feature = "enterprise")]
 mod snowflake_executor;
 
+mod ansible_executor;
 mod bash_executor;
 mod bun_executor;
 pub mod common;
@@ -25,7 +26,6 @@ mod rust_executor;
 mod worker;
 mod worker_flow;
 mod worker_lockfiles;
-mod ansible_executor;
 pub use worker::*;
 
 pub use result_processor::handle_job_error;