Configuré un código de Python para ejecutar Selenium chromedriver.exe. Al final de la ejecución, tengo browser.close()que cerrar la instancia. ( browser = webdriver.Chrome()) Creo que debería liberarse chromedriver.exede la memoria (estoy en Windows 7). Sin embargo, después de cada ejecución, queda una chromedriver.exeinstancia en la memoria. Espero que haya una forma de escribir algo en Python para matar el chromedriver.exeproceso. Obviamente browser.close()no hace el trabajo. Gracias.

según la API de Selenium, debería llamar, browser.quit()ya que este método cerrará todas las ventanas y matará el proceso. Aún debe usar browser.quit().

Sin embargo : en mi lugar de trabajo, hemos notado un gran problema al intentar ejecutar pruebas de chromedriver en la plataforma Java, donde el chromedriver.exe todavía existe incluso después de usarlo browser.quit(). Para contrarrestar esto, creamos un archivo por lotes similar al siguiente, que solo fuerza el cierre de los procesos.

kill_chromedriver.bat

@echo off
rem   just kills stray local chromedriver.exe instances.
rem   useful if you are trying to clean your project, and your ide is complaining.

taskkill /im chromedriver.exe /f

Dado que chromedriver.exe no es un programa enorme y no consume mucha memoria, no debería tener que ejecutar esto cada vez, sino solo cuando presenta un problema. Por ejemplo, al ejecutar Proyecto-> Limpiar en Eclipse.

browser.close() cerrará solo la ventana de Chrome actual.

browser.quit() debe cerrar todas las ventanas abiertas, luego salir de webdriver.

En teoría, llamar a browser.Quit cerrará todas las pestañas del navegador y terminará el proceso.

Sin embargo, en mi caso no pude hacer eso, ya que ejecuté varias pruebas en paralelo, no quería hacer una prueba para cerrar ventanas a otras. Por lo tanto, cuando mis pruebas terminan de ejecutarse, todavía quedan muchos procesos "chromedriver.exe" en ejecución.

Para superar eso, escribí un código de limpieza simple (C #):

Process[] chromeDriverProcesses =  Process.GetProcessesByName("chromedriver");

foreach(var chromeDriverProcess in chromeDriverProcesses)
{
     chromeDriverProcess.Kill();
}

Tuve éxito al usar driver.close()antes driver.quit(). Anteriormente solo usaba driver.quit().

//Calling close and then quit will kill the driver running process.


driver.close();

driver.quit();

Es un poco extraño pero me funciona. Tuve un problema similar, después de investigar un poco, descubrí que todavía había una acción de interfaz de usuario en el navegador (carga de URL más o menos), cuando presioné WebDriver.Quit().

La solución para mí (aunque muy desagradable) fue agregar una Sleep()de 3 segundos antes de llamar a Quit ().

Esta respuesta es cómo deshacerse correctamente del controlador en C #

Si desea utilizar un mecanismo 'adecuado' que debería utilizarse para 'ordenar' después de ejecutar ChromeDriver , debería utilizar IWebDriver.Dispose();

Realiza tareas definidas por la aplicación asociadas con la liberación, liberación o restablecimiento de recursos no administrados. (Heredado de IDisposable).

Normalmente lo implemento IDisposableen la clase que se ocupa deIWebDriver

public class WebDriverController : IDisposable
{
    public IWebDriver Driver;

    public void Dispose()
    {
        this.Driver.Dispose();
    }
}

y utilícelo como:

using (var controller = new WebDriverController())
{
  //code goes here
}

Espero que esto te ahorre algo de tiempo

Elimine varios procesos desde la línea de comandos Lo primero que debe hacer es abrir un símbolo del sistema y luego usar el comando taskkill con la siguiente sintaxis:

taskkill /F /IM <processname.exe> /T

Estos parámetros eliminarán por la fuerza cualquier proceso que coincida con el nombre del ejecutable que especifique. Por ejemplo, para eliminar todos los procesos iexplore.exe, usaríamos:

taskkill /F /IM iexplore.exe

Código c #

utilizando System.Diagnostics;

utilizando System.Management;

        public void KillProcessAndChildren(string p_name)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
          ("Select * From Win32_Process Where Name = '"+ p_name +"'");

        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {

            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch (ArgumentException)
            {
                break;
            }
        }

    }

y esta función

        public void KillProcessAndChildren(int pid)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
         ("Select * From Win32_Process Where ParentProcessID=" + pid);
        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {

            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch
            {
                break;
            }
        }

        try
        {
            Process proc = Process.GetProcessById(pid);

            proc.Kill();
        }
        catch (ArgumentException)
        {
            // Process already exited.
        }
    }

Vocación

                try
            {
                 KillProcessAndChildren("chromedriver.exe");
            }
            catch
            {

            }

Tuve el mismo problema al ejecutarlo en Python y tuve que ejecutar manualmente el comando 'killall' para matar todos los procesos. Sin embargo, cuando implementé el controlador usando el protocolo de administración de contexto de Python , todos los procesos desaparecieron. Parece que el intérprete de Python hace un buen trabajo limpiando las cosas.

Aquí está la implementación:

class Browser:
    def __enter__(self):
        self.options = webdriver.ChromeOptions()
        self.options.add_argument('headless')
        self.driver = webdriver.Chrome(chrome_options=self.options)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.driver.close()
        self.driver.quit()

Y el uso:

with Browser() as browser:
    browser.navigate_to_page()

Entonces, puedes usar lo siguiente:

driver.close()

Cerrar el navegador (emula presionar el botón de cierre)

driver.quit()

Salir del navegador (emula la selección de la opción de salir)

driver.dispose()

Salir del navegador (intenta cerrar todas las pestañas y luego salir)

Sin embargo, si TODAVÍA tiene problemas con las instancias colgadas (como yo), es posible que también desee eliminar la instancia. Para hacer eso, necesita el PID de la instancia de Chrome.

import os
import signal 
driver = webdriver.Chrome()
driver.get(('http://stackoverflow.com'))

def get_pid(passdriver):
    chromepid = int(driver.service.process.pid)
    return (chromepid)

def kill_chrome(thepid)
    try:
        os.kill(pid, signal.SIGTERM)
        return 1
    except:
        return 0

print ("Loaded thing, now I'mah kill it!")
try:
    driver.close()
    driver.quit()
    driver.dispose()
except:
    pass

kill_chrome(chromepid)

Si queda una instancia de Chrome después de eso, me comeré mi sombrero. :(

Código Python:

try:
    # do my automated tasks
except:
    pass
finally:
    driver.close()
    driver.quit()

Sé que esta es una pregunta algo antigua, pero pensé en compartir lo que funcionó para mí. Estaba teniendo problemas con Eclipse, no mataría los procesos, por lo que tenía un montón de procesos fantasmas dando vueltas después de probar el código usando el corredor de Eclipse.

Mi solución fue ejecutar Eclipse como administrador. Eso me lo arregló. Parece que Windows no permitía que Eclipse cerrara el proceso que generó.

He usado lo siguiente en nightwatch.js en afterEach hooks.

afterEach: function(browser, done) {
    // performing an async operation
    setTimeout(function() {
        // finished async duties
        done();
        browser.closeWindow();
        browser.end();
    }, 200);
}

.closeWindow () simplemente cierra la ventana. (Pero no funcionará para varias ventanas abiertas). Mientras que .end () finaliza todos los procesos restantes de Chrome.

Tengo este problema. Sospecho que se debe a la versión de Serenity BDD y Selenium. El proceso de cromedriver nunca se libera hasta que finaliza todo el conjunto de pruebas. Solo hay 97 pruebas, pero el hecho de que 97 procesos consuman la memoria de un servidor que no tiene muchos recursos puede afectar el rendimiento.

Para abordar hice 2 cosas (esto es específico de Windows).

1. antes de cada prueba (anotado con @Before) obtenga el ID de proceso (PID) del proceso del controlador cromado con:

   List<Integer> pids = new ArrayList<Integer>();
   String out;
   Process p = Runtime.getRuntime().exec("tasklist /FI \"IMAGENAME eq chromedriver.exe*\"");
   BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
   while ((out = input.readLine()) != null) {
       String[] items = StringUtils.split(out, " ");
       if (items.length > 1 && StringUtils.isNumeric(items[1])) {
           pids.add(NumberUtils.toInt(items[1]));
       }
   }
   

2. después de cada prueba (anotado con @After) elimine el PID con:

   Runtime.getRuntime().exec("taskkill /F /PID " + pid);
   

Vine aquí inicialmente pensando que seguramente esto se habría respondido / resuelto, pero después de leer todas las respuestas, me sorprendió un poco que nadie intentara reunir los tres métodos:

try
{
    blah
}
catch
{
    blah
}
finally
{
    driver.Close(); // Close the chrome window
    driver.Quit(); // Close the console app that was used to kick off the chrome window
    driver.Dispose(); // Close the chromedriver.exe
}

Solo estaba aquí para buscar respuestas y no tenía la intención de proporcionar una. Entonces, la solución anterior se basa solo en mi experiencia. Estaba usando el controlador de Chrome en una aplicación de consola C # y pude limpiar los procesos persistentes solo después de llamar a los tres métodos juntos.

Para usuarios de Ubuntu / Linux: - el comando es pkillo killall. pkillgeneralmente se recomienda, ya que en algunos sistemas, killallrealmente matará todos los procesos.

Estoy usando Protractor con directConnect. La desactivación de la opción "--no-sandbox" solucionó el problema.

// Capabilities to be passed to the webdriver instance.
capabilities: {
  'directConnect': true,
  'browserName': 'chrome',
  chromeOptions: {
      args: [
        //"--headless",
        //"--hide-scrollbars",
        "--disable-software-rasterizer",
        '--disable-dev-shm-usage',
        //"--no-sandbox",
        "incognito",
        "--disable-gpu",
        "--window-size=1920x1080"]
  }
},

• Asegúrese de obtener la instancia del controlador como Singleton
• luego Aplicar al final
• driver.close ()
• driver.quit ()

Nota: Ahora, si vemos el administrador de tareas, no encontrará ningún controlador o proceso de Chrome aún colgando.

He mirado todas las respuestas y las he probado todas. Prácticamente los recopilé todos en uno como un 'Cierre de seguridad'. Esto en c #

NOTA: puede cambiar el parámetro de la aplicación IModule al del controlador real.

 public class WebDriverCleaner
{

    public static void CloseWebDriver(IModule app)
    {
        try
        {
            if (app?.GetDriver() != null)
            {
                app.GetDriver().Close();
                Thread.Sleep(3000); // Gives time for everything to close before quiting
                app.GetDriver().Quit();
                app.GetDriver().Dispose();
                KillProcessAndChildren("chromedriver.exe"); // One more to make sure we get rid of them chromedrivers.
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }

    public static void KillProcessAndChildren(string p_name)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
            ("Select * From Win32_Process Where Name = '" + p_name + "'");

        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {
            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch (ArgumentException)
            {
                break;
            }
        }

    }


    public static void KillProcessAndChildren(int pid)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + pid);
        ManagementObjectCollection moc = searcher.Get();

        foreach (ManagementObject mo in moc)
        {
            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch
            {
                break;
            }
        }

        try
        {
            Process proc = Process.GetProcessById(pid);
            proc.Kill();
        }
        catch (ArgumentException)
        {
            // Process already exited.
        }
    }

}

Observado en la versión 3.141.0:

Si inicializa su ChromeDriver solo con ChromeOptions, quit () no cerrará chromedriver.exe.

    ChromeOptions chromeOptions = new ChromeOptions();
    ChromeDriver driver = new ChromeDriver(chromeOptions);
    // .. do stuff ..
    driver.quit()

Si crea y pasa un ChromeDriverService, quit () cerrará chromedriver.exe correctamente.

    ChromeDriverService driverService = ChromeDriverService.CreateDefaultService();
    ChromeOptions chromeOptions = new ChromeOptions();
    ChromeDriver driver = new ChromeDriver(driverService, chromeOptions);
    // .. do stuff ..
    driver.quit()

Simplemente uso en cada prueba un método tearDown () como sigue y no tengo ningún problema.

@AfterTest
public void tearDown() {
    driver.quit();
    driver = null;
}

Después de salir de la instancia del controlador, límpiela de la caché con driver = null

Espero la respuesta a la pregunta

Hay otra forma que funciona solo para Windows, pero ahora está en desuso. funciona para versiones anteriores de selenio (funciona en la versión 3.11.0).

import org.openqa.selenium.os.WindowsUtils;

 WindowsUtils.killByName("chromedriver.exe") // any process name you want

Debe aplicar cerca antes de dejar de fumar

driver.close()
driver.quit()