| """Launches Cobalt and runs webdriver-based Cobalt tests.""" |
| |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| import os |
| import re |
| import sys |
| import thread |
| import threading |
| |
| import _env # pylint: disable=unused-import |
| from starboard.tools import abstract_launcher |
| |
| # pylint: disable=C6204 |
| sys.path.insert(0, os.path.dirname(os.path.realpath(__file__))) |
| import webdriver_utils |
| |
| # Pattern to match Cobalt log line for when the WebDriver port has been |
| # opened. |
| RE_WEBDRIVER_LISTEN = re.compile(r'Starting WebDriver server on port (\d+)') |
| # Pattern to match Cobalt log line for when a WindowDriver has been created. |
| RE_WINDOWDRIVER_CREATED = re.compile( |
| r'^\[\d+/\d+:INFO:browser_module\.cc\(\d+\)\] Created WindowDriver: ID=\S+') |
| # Pattern to match Cobalt log line for when a WebModule is has been loaded. |
| RE_WEBMODULE_LOADED = re.compile( |
| r'^\[\d+/\d+:INFO:browser_module\.cc\(\d+\)\] Loaded WebModule') |
| |
| DEFAULT_STARTUP_TIMEOUT_SECONDS = 2 * 60 |
| WEBDRIVER_HTTP_TIMEOUT_SECONDS = 2 * 60 |
| COBALT_EXIT_TIMEOUT_SECONDS = 5 |
| |
| COBALT_WEBDRIVER_CAPABILITIES = { |
| 'browserName': 'cobalt', |
| 'javascriptEnabled': True, |
| 'platform': 'LINUX' |
| } |
| |
| _launcher = None |
| _webdriver = None |
| _windowdriver_created = threading.Event() |
| _webmodule_loaded = threading.Event() |
| |
| |
| def SendResume(): |
| """Sends a resume signal to start Cobalt from preload.""" |
| _launcher.SendResume() |
| |
| |
| def SendSuspend(): |
| """Sends a system signal to put Cobalt into suspend state.""" |
| _launcher.SendSuspend() |
| |
| |
| def GetWebDriver(): |
| """Returns the active connect WebDriver instance.""" |
| return _webdriver |
| |
| |
| def GetWindowDriverCreated(): |
| """Returns the WindowDriver created instance.""" |
| return _windowdriver_created |
| |
| |
| def GetWebModuleLoaded(): |
| """Returns the WebModule loaded instance.""" |
| return _webmodule_loaded |
| |
| |
| class TimeoutException(Exception): |
| pass |
| |
| |
| class CobaltRunner(object): |
| """Runs a Cobalt browser w/ a WebDriver client attached.""" |
| test_script_started = threading.Event() |
| selenium_webdriver_module = None |
| launcher = None |
| webdriver = None |
| thread = None |
| failed = False |
| should_exit = threading.Event() |
| |
| def __init__(self, platform, config, device_id, target_params, out_directory, |
| url, log_file, success_message): |
| global _launcher |
| |
| self.selenium_webdriver_module = webdriver_utils.import_selenium_module( |
| 'webdriver') |
| |
| command_line_args = [] |
| if target_params is not None: |
| split_target_params = target_params.split(' ') |
| for param in split_target_params: |
| command_line_args.append(param) |
| command_line_args.append('--debug_console=off') |
| command_line_args.append('--null_savegame') |
| command_line_args.append('--url=' + url) |
| |
| self.log_file = log_file |
| self.success_message = success_message |
| |
| read_fd, write_fd = os.pipe() |
| |
| self.launcher_read_pipe = os.fdopen(read_fd, 'r') |
| self.launcher_write_pipe = os.fdopen(write_fd, 'w') |
| |
| self.launcher = abstract_launcher.LauncherFactory( |
| platform, |
| 'cobalt', |
| config, |
| device_id=device_id, |
| target_params=command_line_args, |
| output_file=self.launcher_write_pipe, |
| out_directory=out_directory) |
| _launcher = self.launcher |
| |
| def _HandleLine(self): |
| """Reads log lines to determine when cobalt/webdriver server start.""" |
| while True: |
| line = self.launcher_read_pipe.readline() |
| if line: |
| self.log_file.write(line) |
| else: |
| break |
| |
| if RE_WINDOWDRIVER_CREATED.search(line): |
| _windowdriver_created.set() |
| continue |
| |
| if RE_WEBMODULE_LOADED.search(line): |
| _webmodule_loaded.set() |
| continue |
| |
| # Wait for WebDriver port here then connect |
| if self.test_script_started.is_set(): |
| continue |
| |
| match = RE_WEBDRIVER_LISTEN.search(line) |
| if not match: |
| continue |
| |
| port = match.group(1) |
| print('WebDriver port opened:' + port + '\n', file=self.log_file) |
| self._StartWebdriver(port) |
| |
| def __enter__(self): |
| |
| self.runner_thread = threading.Thread(target=self.Run) |
| self.runner_thread.start() |
| |
| self.reader_thread = threading.Thread(target=self._HandleLine) |
| # Make this thread daemonic so that it always exits |
| self.reader_thread.daemon = True |
| self.reader_thread.start() |
| try: |
| self.WaitForStart() |
| except KeyboardInterrupt: |
| # potentially from thread.interrupt_main(). We will treat as |
| # a timeout regardless |
| |
| self.Exit(should_fail=True) |
| raise TimeoutException |
| return self |
| |
| def __exit__(self, exc_type, exc_value, exc_traceback): |
| # The unittest module terminates with a SystemExit |
| # If this is a successful exit, then this is a successful run |
| success = exc_type is None or (exc_type is SystemExit and |
| not exc_value.code) |
| self.Exit(should_fail=not success) |
| |
| def Exit(self, should_fail=False): |
| if not self.should_exit.is_set(): |
| self._SetShouldExit(failed=should_fail) |
| |
| def _SetShouldExit(self, failed=False): |
| """Indicates Cobalt process should exit.""" |
| self.failed = failed |
| self.should_exit.set() |
| |
| try: |
| self.launcher.Kill() |
| except Exception as e: # pylint: disable=broad-except |
| sys.stderr.write('Exception killing launcher:\n') |
| sys.stderr.write('{}\n'.format(str(e))) |
| |
| self.runner_thread.join(COBALT_EXIT_TIMEOUT_SECONDS) |
| if self.runner_thread.isAlive(): |
| sys.stderr.write('***Runner thread still alive***\n') |
| # Once the write end of the pipe has been closed by the launcher, the reader |
| # thread will get EOF and exit. |
| self.reader_thread.join(COBALT_EXIT_TIMEOUT_SECONDS) |
| if self.reader_thread.isAlive(): |
| sys.stderr.write('***Reader thread still alive, exiting anyway***\n') |
| try: |
| self.launcher_read_pipe.close() |
| except IOError: |
| # Ignore error from closing the pipe during a blocking read |
| pass |
| |
| def _StartWebdriver(self, port): |
| global _webdriver |
| host, webdriver_port = self.launcher.GetHostAndPortGivenPort(port) |
| url = 'http://{}:{}/'.format(host, webdriver_port) |
| self.webdriver = self.selenium_webdriver_module.Remote( |
| url, COBALT_WEBDRIVER_CAPABILITIES) |
| self.webdriver.command_executor.set_timeout(WEBDRIVER_HTTP_TIMEOUT_SECONDS) |
| print('Selenium Connected\n', file=self.log_file) |
| _webdriver = self.webdriver |
| self.test_script_started.set() |
| |
| def WaitForStart(self): |
| """Waits for the webdriver client to attach to Cobalt.""" |
| startup_timeout_seconds = self.launcher.GetStartupTimeout() |
| if not startup_timeout_seconds: |
| startup_timeout_seconds = DEFAULT_STARTUP_TIMEOUT_SECONDS |
| |
| if not self.test_script_started.wait(startup_timeout_seconds): |
| self.Exit(should_fail=True) |
| raise TimeoutException |
| print('Cobalt started', file=self.log_file) |
| |
| def Run(self): |
| """Thread run routine.""" |
| try: |
| print('Running launcher', file=self.log_file) |
| self.launcher.Run() |
| print( |
| 'Cobalt terminated. failed: ' + str(self.failed), file=self.log_file) |
| if not self.failed: |
| print('{}\n'.format(self.success_message)) |
| # pylint: disable=broad-except |
| except Exception as ex: |
| sys.stderr.write('Exception running Cobalt ' + str(ex)) |
| finally: |
| self.launcher_write_pipe.close() |
| if not self.should_exit.is_set(): |
| # If the main thread is not expecting us to exit, |
| # we must interrupt it. |
| thread.interrupt_main() |
| return 0 |
