refactor webdriver spawn function

Signed-off-by: Andrei Gherghescu <[email protected]>

Author: andrei-ng

plotly_static/src/webdriver.rs

@@ -208,6 +208,56 @@ impl WebDriver {
 
     fn spawn_process(&self, driver_path: &Option<PathBuf>, port: u32) -> Result<Child> {
         let driver_path = driver_path.as_ref().unwrap(); // Safe unwrap since we validated above
+
+        let mut command = Self::create_command(driver_path, port);
+        Self::log_command(&command);
+
+        match command.spawn() {
+            Ok(child) => Ok(child),
+            Err(e) => {
+                #[cfg(not(target_os = "windows"))]
+                {
+                    Err(self.handle_spawn_error(e, &command, "standard method"))
+                }
+                #[cfg(target_os = "windows")]
+                {
+                    self.spawn_with_fallback(driver_path, port, e, &command)
+                }
+            }
+        }
+    }
+
+    /// Windows-specific fallback spawn method when CREATE_NO_WINDOW fails
+    #[cfg(target_os = "windows")]
+    fn spawn_with_fallback(
+        &self,
+        driver_path: &PathBuf,
+        port: u32,
+        original_error: std::io::Error,
+        original_command: &Command,
+    ) -> Result<Child> {
+        // If CREATE_NO_WINDOW fails, try without any special flags
+        error!("Failed to spawn with CREATE_NO_WINDOW: {original_error}");
+        error!("Trying without special creation flags...");
+
+        let mut fallback_command = Self::standard_command(driver_path, port);
+        Self::log_command(&fallback_command);
+
+        match fallback_command.spawn() {
+            Ok(child) => {
+                info!("Successfully spawned WebDriver without special creation flags");
+                Ok(child)
+            }
+            Err(fallback_e) => {
+                error!("Original error: {original_error}");
+                error!("Fallback error: {fallback_e}");
+                Err(self.handle_spawn_error(fallback_e, &fallback_command, "fallback method"))
+            }
+        }
+    }
+
+    /// Creates a command with standard configuration (no Windows flags)
+    fn standard_command(driver_path: &PathBuf, port: u32) -> Command {
         let mut command = Command::new(driver_path);
         command.arg(format!("--port={port}"));
 
@@ -220,81 +270,60 @@ impl WebDriver {
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
 
+        command
+    }
+
+    /// Creates a command with Windows-specific flags
+    #[cfg(target_os = "windows")]
+    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
+        use std::os::windows::process::CommandExt;
+
+        let mut command = Self::standard_command(driver_path, port);
+        // Try with CREATE_NO_WINDOW for headless operation
+        command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
+        command
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn create_command(driver_path: &PathBuf, port: u32) -> Command {
+        Self::standard_command(driver_path, port)
+    }
+
+    /// Logs command execution details
+    fn log_command(command: &Command) {
         info!(
             "Executing command: {:?} {:?}",
             command.get_program(),
             command.get_args()
         );
+    }
+
+    /// Handles spawn errors with appropriate logging and diagnostics
+    fn handle_spawn_error(
+        &self,
+        e: std::io::Error,
+        command: &Command,
+        attempt: &str,
+    ) -> anyhow::Error {
+        error!("Failed to spawn '{WEBDRIVER_BIN}' with {attempt}: {e}");
+        error!(
+            "Command was: {:?} {:?}",
+            command.get_program(),
+            command.get_args()
+        );
 
         #[cfg(target_os = "windows")]
-        {
-            use std::os::windows::process::CommandExt;
-            // Try with CREATE_NO_WINDOW for headless operation
-            command.creation_flags(0x08000000); // CREATE_NO_WINDOW flag
+        if attempt == "CREATE_NO_WINDOW" {
+            error!("Windows: Check if antivirus is blocking the process");
+            error!("Windows: Check if the binary has proper permissions");
         }
 
-        // Try to spawn the process
-        match command.spawn() {
-            Ok(child) => Ok(child),
-            Err(e) => {
-                #[cfg(target_os = "windows")]
-                {
-                    // If CREATE_NO_WINDOW fails, try without any special flags
-                    error!("Failed to spawn with CREATE_NO_WINDOW: {e}");
-                    error!("Trying without special creation flags...");
-
-                    let mut fallback_command = Command::new(driver_path);
-                    fallback_command.arg(format!("--port={port}"));
-
-                    #[cfg(feature = "chromedriver")]
-                    fallback_command.arg("--verbose");
-
-                    fallback_command
-                        .stdin(Stdio::piped())
-                        .stdout(Stdio::piped())
-                        .stderr(Stdio::piped());
-
-                    match fallback_command.spawn() {
-                        Ok(child) => {
-                            info!("Successfully spawned WebDriver without special creation flags");
-                            Ok(child)
-                        }
-                        Err(fallback_e) => {
-                            error!("Failed to spawn '{WEBDRIVER_BIN}' with fallback method: {fallback_e}");
-                            error!("Original error: {e}");
-                            error!("Fallback error: {fallback_e}");
-                            error!(
-                                "Command was: {:?} {:?}",
-                                command.get_program(),
-                                command.get_args()
-                            );
-                            error!("Windows: Check if antivirus is blocking the process");
-                            error!("Windows: Check if the binary has proper permissions");
-                            error!(
-                                "WebDriver diagnostics after spawn failure:\n{}",
-                                self.get_diagnostics()
-                            );
-                            Err(anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", fallback_e))
-                        }
-                    }
-                }
+        error!(
+            "WebDriver diagnostics after spawn failure:\n{}",
+            self.get_diagnostics()
+        );
 
-                #[cfg(not(target_os = "windows"))]
-                {
-                    error!("Failed to spawn '{WEBDRIVER_BIN}': {e}");
-                    error!(
-                        "Command was: {:?} {:?}",
-                        command.get_program(),
-                        command.get_args()
-                    );
-                    error!(
-                        "WebDriver diagnostics after spawn failure:\n{}",
-                        self.get_diagnostics()
-                    );
-                    Err(anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e))
-                }
-            }
-        }
+        anyhow!("Failed to spawn '{WEBDRIVER_BIN}': {}", e)
     }
 
     fn setup_output_monitoring(&self, child: &mut Child, port: u32) {