0

Background

I'm using Selenium and Python to automate display and navigation of a website in Chromium on Ubuntu MATE 16.04 on a Raspberry Pi 3. (Think unattended digital signage.) This combination was working great until today when the newest version of Chromium (with matching ChromeDriver) installed via automatic updates.

Because Chromium needed to perform some upgrade housekeeping tasks the next time it started up, it took a little longer than usual. Keep in mind that this is on a Raspberry Pi, so I/O is severely bottlenecked by the SD card. Unfortunately, it took long enough that my Python script failed because the ChromeDriver gave up on Chromium ever starting:

Traceback (most recent call last):
  File "call-tracker-start", line 15, in <module>
    browser = webdriver.Chrome(executable_path=chromedriver_path, options=chrome_options)
  File "/home/pi/.local/lib/python3.5/site-packages/selenium/webdriver/chrome/webdriver.py", line 75, in __init__
    desired_capabilities=desired_capabilities)
  File "/home/pi/.local/lib/python3.5/site-packages/selenium/webdriver/remote/webdriver.py", line 154, in __init__
    self.start_session(desired_capabilities, browser_profile)
  File "/home/pi/.local/lib/python3.5/site-packages/selenium/webdriver/remote/webdriver.py", line 243, in start_session
    response = self.execute(Command.NEW_SESSION, parameters)
  File "/home/pi/.local/lib/python3.5/site-packages/selenium/webdriver/remote/webdriver.py", line 312, in execute
    self.error_handler.check_response(response)
  File "/home/pi/.local/lib/python3.5/site-packages/selenium/webdriver/remote/errorhandler.py", line 242, in check_response
    raise exception_class(message, screen, stacktrace)
selenium.common.exceptions.WebDriverException: Message: chrome not reachable
  (Driver info: chromedriver=2.35 (0),platform=Linux 4.4.38-v7+ armv7l)

Of course, when the script dies after throwing this exception, the Chromium instance is killed before it can finish its housekeeping, which means that next time it has to start over, so it takes just as long as the last time and fails just as hard.

If I then manually intervene and run Chromium as a normal user, I just... wait... a minute... or two, for Chromium to finish its upgrade housekeeping, then it opens its browser window, and then I cleanly quit the application. Now that the housekeeping is done, Chromium starts up the next time at a more normal speed, so all of the sudden my Python script runs without any error because the ChromeDriver sees Chromium finish launching within its accepted timeout window.

Everything will likely be fine until the next automatic update comes down, and then this same problem will happen all over again. I don't want to have to manually intervene after every update, nor do I want to disable automatic updates.

The root of the question

How can I tell ChromeDriver not to give up so quickly on launching Chromium?

I looked for some sort of timeout value that I could set, but I couldn't find any in the ChromeDriver or Selenium for Python documentation.

Interestingly, there is a timeout argument that can be passed to the Firefox WebDriver, as shown in the Selenium for Python API documentation:

timeout – Time to wait for Firefox to launch when using the extension connection.

This parameter is also listed for the Internet Explorer WebDriver, but it's notably absent in the Chrome WebDriver API documentation.

I also wouldn't mind passing something directly to ChromeDriver via service_args, but I couldn't find any relevant options in the ChromeDriver docs.

Update: found root cause of post-upgrade slowness

After struggling with finding a way to reproduce this problem in order to test solutions, I was able to pinpoint the reason Chromium takes forever to launch after an upgrade.

It seems that, as part of its post-upgrade housekeeping, Chromium rebuilds the user's font cache. This is a CPU & I/O intensive process that is especially hard on a Raspberry Pi and its SD card, hence the extreme 2.5 minute launch time whenever the font cache has to be rebuilt.

The problem can be reproduced by purposely deleting the font cache, which forces a rebuild:

pi@rpi-dev1:~$ killall chromium-browser
pi@rpi-dev1:~$ time chromium-browser --headless --disable-gpu --dump-dom 'about:blank'
[0405/132706.970822:ERROR:gpu_process_transport_factory.cc(1019)] Lost UI shared context.
<html><head></head><body></body></html>

real    0m0.708s
user    0m0.340s
sys     0m0.200s

pi@rpi-dev1:~$ rm -Rf ~/.cache/fontconfig
pi@rpi-dev1:~$ time chromium-browser --headless --disable-gpu --dump-dom 'about:blank'
[0405/132720.917590:ERROR:gpu_process_transport_factory.cc(1019)] Lost UI shared context.
<html><head></head><body></body></html>

real    2m9.449s
user    2m8.670s
sys     0m0.590s
ven42
  • 166
  • 6
  • Can you update the question with the _Selenium_, _ChromeDriver_ and _Chrome_ version you are using along with the complete error trace logs and the exact usecase you are looking at along with your _code trials_? – undetected Selenium Mar 29 '18 at 05:06

3 Answers3

0

You are right, there is no option to explicitly set the timeout of the initial driver creation. I would recommend visiting their git page HERE and creating a new issue. It also has the links for the direct ChromeDriver site in case you want to create a bug there. Currently, there is no option to set timeout that I could find.

You could try something like this in the meantime though:

import webbrowser
from selenium import webdriver
from selenium.common.exceptions import WebDriverException

try:
    driver = webdriver.Chrome()
except WebDriverException:
    webbrowser.open_new('http://www.Google.com')
# Let this try and get Chrome open, then go back and use webdriver

Here is the documentation on webbrowser: https://docs.python.org/3/library/webbrowser.html

PixelEinstein
  • 1,713
  • 1
  • 8
  • 17
  • This answer was helpful in leading me down the right path, though I didn't find `webbrowser.open_new()` useful because it returns immediately instead of blocking while Chromium loads. I'd love to give you a +1, but I'm sorry that I haven't earned enough rep yet to upvote. – ven42 Apr 06 '18 at 01:07
0

As per your question without your code trial it would be tough to analyze the reason behind the error which you are seeing as :

selenium.common.exceptions.WebDriverException: Message: chrome not reachable

Perhaps a more details about the version info of the binaries you are using would have helped us in someway.

Factually, asking ChromeDriver to wait longer for Chrome to launch before giving up won't help us as the default configuration of ChromeDriver takes care of the optimum needs.

However WebDriverException: Message: chrome not reachable is pretty common issue when the binary versions are incompatible. You can find a detailed discussion about this issue at org.openqa.selenium.WebDriverException: chrome not reachable - when attempting to start a new session

undetected Selenium
  • 183,867
  • 41
  • 278
  • 352
  • If it were incompatible binaries wouldn't it be consistently causing the `chrome not reachable`, I have gotten that error after updating Chrome before, but it happened every time. All they are doing is opening Chromium themselves and letting it open **once** after automatic updates, and it works. I would think that would lead to another problem since they aren't changing their versions but it works after one **long running** clean open. – PixelEinstein Mar 29 '18 at 16:11
  • @PixelEinstein See OP's case and your case both have the same trigger **newest version of Chromium**. For the record **Chromium Project** clearly provides the dependency in the **Release Notes** as a heading. Deviation from the recommended configuration/settings are against all the _Best Practices_. – undetected Selenium Mar 29 '18 at 16:18
  • I assumed they were running on current versions since they stated they were installing current versions of both Chromedriver and Chromium. It would help if we knew what version of Chromium and Selenium they were running, their chromedriver is `2.35`, which is **not** current if Chromium is auto updating. You are probably right. – PixelEinstein Mar 29 '18 at 16:32
  • Apart from `2.35` I am more suspicious about the source of the binary as I can see a index `(0)` as in `Driver info: chromedriver=2.35 (0)` – undetected Selenium Mar 29 '18 at 16:35
0

The bad news

It turns out that not only is there no timeout option for Selenium to pass to ChromeDriver, but short of recompiling your own custom ChromeDriver, there is currently no way to change this value programmatically whatsoever. Sadly, looking at the source code shows that Google has hard-coded a timeout value of 60 seconds!

from chromium /src/chrome/test/chromedriver/chrome_launcher.cc@208: 
std::unique_ptr<DevToolsHttpClient> client(new DevToolsHttpClient(
    address, context_getter, socket_factory, std::move(device_metrics),
    std::move(window_types), capabilities->page_load_strategy));
base::TimeTicks deadline =
    base::TimeTicks::Now() + base::TimeDelta::FromSeconds(60);
Status status = client->Init(deadline - base::TimeTicks::Now());

Until this code is changed to allow custom deadlines, the only option is a workaround.

The workaround

I ended up taking an approach that "primed" Chromium before having Selenium call ChromeDriver. This gets that one-time, post-upgrade slow start out of the way before ChromeDriver ever begins its countdown. The answer @PixelEinstein gave helped lead me down the right path, but this solution differs in two ways:

  1. The call to open standalone Chromium here is blocking, while webbrowser.open_new() is not.
  2. Standalone Chromium is always launched before ChromeDriver whether it is needed or not. I did this because waiting one minute for ChromeDriver to timeout, then waiting another 2.5 minutes for Chromium to start, then trying ChromeDriver again created a total delay of just over 3.5 minutes. Launching Chromium as the first action brings the total wait time down to about 2.5 minutes, as you skip the initial ChromeDriver timeout. On occasions when the long startup time doesn't occur, then this "double loading" of Chromium is negligible, as the whole process finishes in a matter of seconds.

Here's the code snippet:

#!/usr/bin/env python3
import subprocess
from selenium import webdriver

some_site = 'http://www.google.com'
chromedriver_path = '/usr/lib/chromium-browser/chromedriver'

# Block until Chromium finishes launching and self-terminates
subprocess.run(['chromium-browser', '--headless', '--disable-gpu', '--dump-dom', 'about:blank'])

browser = webdriver.Chrome(executable_path=chromedriver_path)
browser.get(some_site)
# Continue on with your Selenium business...

Before instantiating a webdriver.Chrome() object, this waits for Chromium to finish its post-upgrade housekeeping no matter how long it takes. Chromium is launched in headless mode where --dump-dom is a one-shot operation that writes the requested web page (in this case about:blank) to stdout, which is ignored. Chromium self-terminates after completing the operation, which then returns from the subprocess.run() call, unblocking program flow. After that, it's safe to let ChromeDriver start its countdown, as Chromium will launch in a matter of seconds.

ven42
  • 166
  • 6