Skonfigurowałem kod Pythona, aby uruchomić Selenium chromedriver.exe. Pod koniec biegu muszę browser.close()zamknąć instancję. ( browser = webdriver.Chrome()) Uważam, że powinien zwolnić się chromedriver.exez pamięci (pracuję na Windows 7). Jednak po każdym uruchomieniu chromedriver.exew pamięci pozostaje jedna instancja. Mam nadzieję, że jest sposób, w jaki mogę napisać coś w Pythonie, aby zabić chromedriver.exeproces. Oczywiście browser.close()nie działa. Dzięki.

zgodnie z API Selenium, naprawdę powinieneś wywołać, browser.quit()ponieważ ta metoda zamknie wszystkie okna i zabije proces. Nadal powinieneś używać browser.quit().

Jednak : w moim miejscu pracy zauważyliśmy ogromny problem podczas próby wykonania testów chromedriver na platformie Java, gdzie plik chromedriver.exe nadal istnieje nawet po użyciu browser.quit(). Aby temu przeciwdziałać, stworzyliśmy plik wsadowy podobny do tego poniżej, który po prostu wymusza zamknięcie procesów.

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

Ponieważ chromedriver.exe nie jest dużym programem i nie zużywa dużo pamięci, nie powinieneś go uruchamiać za każdym razem, ale tylko wtedy, gdy stwarza problem. Na przykład podczas uruchamiania Project-> Clean in Eclipse.

browser.close() zamknie tylko bieżące okno chrome.

browser.quit() powinien zamknąć wszystkie otwarte okna, a następnie zamknąć sterownik sieciowy.

Teoretycznie wywołanie browser.Quit zamknie wszystkie karty przeglądarki i zakończy proces.

Jednak w moim przypadku nie byłem w stanie tego zrobić - skoro równolegle prowadziłem wiele testów, nie chciałem, aby jeden test zamykał okna dla innych. Dlatego po zakończeniu testów nadal działa wiele procesów „chromedriver.exe”.

Aby temu zaradzić, napisałem prosty kod porządkujący (C #):

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

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

Miałem sukces, używając driver.close()wcześniej driver.quit(). Wcześniej używałem tylko driver.quit().

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


driver.close();

driver.quit();

To trochę dziwne, ale dla mnie działa. Miałem podobny problem, po pewnym kopaniu odkryłem, że w przeglądarce nadal trwa akcja interfejsu użytkownika (ładowanie adresu URL lub coś podobnego), kiedy trafiłemWebDriver.Quit() .

Rozwiązaniem dla mnie (choć bardzo paskudnym) było dodanie Sleep()3 sekund przed wywołaniem Quit ().

Ta odpowiedź brzmi, jak prawidłowo pozbyć się sterownika w C #

Jeśli chcesz użyć „właściwego” mechanizmu, którego należy użyć do „uporządkowania” po uruchomieniu ChromeDriver , powinieneś użyć IWebDriver.Dispose();

Wykonuje zdefiniowane przez aplikację zadania związane ze zwalnianiem, zwalnianiem lub resetowaniem niezarządzanych zasobów. (Odziedziczone po IDisposable.)

Zwykle wdrażam IDisposablena zajęciach, z którymi mam do czynieniaIWebDriver

public class WebDriverController : IDisposable
{
    public IWebDriver Driver;

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

i używaj go jak:

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

Mam nadzieję, że zaoszczędzi ci to trochę czasu

Zabij wiele procesów z wiersza poleceń Pierwszą rzeczą, którą musisz zrobić, to otworzyć wiersz polecenia, a następnie użyć polecenia taskkill z następującą składnią:

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

Te parametry wymuszą zabicie każdego procesu pasującego do nazwy pliku wykonywalnego, który określisz. Na przykład, aby zabić wszystkie procesy iexplore.exe, użylibyśmy:

taskkill /F /IM iexplore.exe

Kod c #

using System.Diagnostics;

using 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;
            }
        }

    }

i ta funkcja

        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.
        }
    }

Powołanie

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

            }

Miałem ten sam problem podczas uruchamiania go w Pythonie i musiałem ręcznie uruchomić polecenie „killall”, aby zabić wszystkie procesy. Jednak kiedy zaimplementowałem sterownik przy użyciu protokołu zarządzania kontekstem Pythona wszystkie procesy zniknęły. Wygląda na to, że interpreter Pythona naprawdę dobrze radzi sobie z porządkowaniem rzeczy.

Oto realizacja:

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()

I użycie:

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

Możesz więc użyć następujących:

driver.close()

Zamknij przeglądarkę (emuluje naciśnięcie przycisku zamykania)

driver.quit()

Zamknij przeglądarkę (emuluje wybranie opcji wyjścia)

driver.dispose()

Zamknij przeglądarkę (próbuje zamknąć każdą kartę, a następnie zamknij)

Jeśli jednak NADAL masz problemy z zawieszonymi instancjami (tak jak ja), możesz również chcieć zabić instancję. Aby to zrobić, potrzebujesz PID instancji 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)

Jeśli po tym pozostanie chromowana instancja, zjem kapelusz. :(

Kod Pythona:

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

Wiem, że jest to trochę stare pytanie, ale pomyślałem, że podzielę się tym, co zadziałało. Miałem problemy z Eclipse - nie zabijało to procesów, więc po przetestowaniu kodu przy użyciu Eclipse runner kręciło się kilka procesów fantomowych.

Moim rozwiązaniem było uruchomienie Eclipse jako administrator. To naprawiło to dla mnie. Wygląda na to, że system Windows nie pozwolił Eclipse na zamknięcie uruchomionego procesu.

Użyłem poniższego w nightwatch.js w afterEach hooków.

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

.closeWindow () po prostu zamyka okno. (Ale nie będzie działać dla wielu otwartych okien). Natomiast .end () kończy wszystkie pozostałe procesy chrome.

Mam ten problem. Podejrzewam, że jest to spowodowane wersją Serenity BDD i Selenium. Proces chromedriver nigdy nie jest zwalniany, dopóki cały zestaw testów nie zostanie zakończony. Jest tylko 97 testów, ale fakt, że 97 procesów pochłania pamięć serwera, który nie ma zbyt wielu zasobów, może mieć wpływ na wydajność.

Aby rozwiązać problem, zrobiłem 2 rzeczy (jest to specyficzne dla systemu Windows).

1. przed każdym testem (z adnotacją @Before) pobierz identyfikator procesu (PID) procesu chromedriver z:

   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. po każdym teście (z adnotacją @After) zabij PID za pomocą:

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

Przyszedłem tutaj początkowo myśląc, że z pewnością byłoby to odpowiedź / rozwiązane, ale po przeczytaniu wszystkich odpowiedzi byłem nieco zaskoczony, że nikt nie próbował połączyć wszystkich trzech metod razem:

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
}

Byłem tu tylko po to, by szukać odpowiedzi i nie zamierzałem ich udzielać. Zatem powyższe rozwiązanie bazuje wyłącznie na moim doświadczeniu. Używałem sterownika Chrome w aplikacji konsolowej C # i udało mi się wyczyścić utrzymujące się procesy dopiero po wywołaniu wszystkich trzech metod razem.

Dla użytkowników Ubuntu / Linux: - komenda jest albo pkillalbo killall. pkilljest ogólnie zalecany, ponieważ w niektórych systemach killallfaktycznie zabija wszystkie procesy.

Używam Protractor z directConnect. Wyłączenie opcji „--no-sandbox” rozwiązało problem.

// 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"]
  }
},

• Upewnij się, że otrzymujesz instancję sterownika jako Singleton
• następnie Zastosuj na końcu
• driver.close ()
• driver.quit ()

Uwaga: teraz, jeśli zobaczymy menedżera zadań, nie znajdziesz żadnego sterownika ani procesu chrome, który nadal się zawiesił

Przejrzałem wszystkie odpowiedzi i przetestowałem je wszystkie. Prawie zebrałem je wszystkie w jeden jako „Zamknięcie bezpieczeństwa”. To w c #

UWAGA, możesz zmienić parametr z aplikacji IModule na parametr aktualnego sterownika.

 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.
        }
    }

}

Obserwowane w wersji 3.141.0:

Jeśli zainicjujesz ChromeDriver tylko przy użyciu ChromeOptions, quit () nie zamknie chromedriver.exe.

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

Jeśli utworzysz i przekażesz usługę ChromeDriverService, quit () zamknie poprawnie plik chromedriver.exe.

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

Po prostu używam w każdym teście metody tearDown () jak następuje i nie mam żadnego problemu.

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

Po zamknięciu instancji sterownika wyczyść ją z pamięci podręcznej przez driver = null

Mam nadzieję, że odpowiem na pytanie

Jest inny sposób, który działa tylko w systemie Windows, ale teraz jest przestarzały. działa z wcześniejszymi wersjami selenu (działa z wersją 3.11.0).

import org.openqa.selenium.os.WindowsUtils;

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

Powinieneś złożyć wniosek przed zakończeniem

driver.close()
driver.quit()