# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
import pprint
import signal
import subprocess
import sys
import time
import traceback
from threading
import Timer
import mozcrash
import psutil
import six
from mozlog
import get_proxy_logger
from mozscreenshot
import dump_screen
from talos.utils
import TalosError
LOG = get_proxy_logger()
class ProcessContext(object):
"""
Store useful results of the browser execution.
"""
def __init__(self, is_launcher=
False):
self.output =
None
self.process =
None
self.is_launcher = is_launcher
@property
def pid(self):
return self.process
and self.process.pid
def kill_process(self):
"""
Kill the process, returning the exit code
or None if the process
is already finished.
"""
parentProc = self.process
# If we're using a launcher process, terminate that instead of us:
kids = parentProc
and parentProc.is_running()
and parentProc.children()
if self.is_launcher
and kids
and len(kids) == 1
and kids[0].is_running():
LOG.debug(
(
"Launcher process {} detected. Terminating parent"
" process {} instead."
).format(parentProc, kids[0])
)
parentProc = kids[0]
if parentProc
and parentProc.is_running():
LOG.debug(
"Terminating %s" % parentProc)
try:
parentProc.terminate()
except psutil.NoSuchProcess:
procs = parentProc.children()
for p
in procs:
c = ProcessContext()
c.process = p
c.kill_process()
return parentProc.returncode
try:
return parentProc.wait(3)
except psutil.TimeoutExpired:
LOG.debug(
"Killing %s" % parentProc)
parentProc.kill()
# will raise TimeoutExpired if unable to kill
return parentProc.wait(3)
class Reader(object):
def __init__(self):
self.output = []
self.got_end_timestamp =
False
self.got_timeout =
False
self.timeout_message =
""
self.got_error =
False
self.proc =
None
def __call__(self, line):
line = six.ensure_str(line)
line = line.strip(
"\r\n")
if line.find(
"__endTimestamp") != -1:
self.got_end_timestamp =
True
elif line ==
"TART: TIMEOUT":
self.got_timeout =
True
self.timeout_message =
"TART"
elif line.startswith(
"TEST-UNEXPECTED-FAIL | "):
self.got_error =
True
if not (
"JavaScript error:" in line
or "JavaScript warning:" in line
or "SyntaxError:" in line
or "TypeError:" in line
):
LOG.process_output(self.proc.pid, line)
self.output.append(line)
def run_browser(
command,
minidump_dir,
timeout=
None,
on_started=
None,
debug=
None,
debugger=
None,
debugger_args=
None,
utility_path=
None,
**kwargs
):
"""
Run the browser using the given `command`.
After the browser prints __endTimestamp, we give it 5
seconds to quit
and kill it
if it
's still alive at that point.
Note that this method ensure that the process
is killed at
the end.
If this
is not possible, an exception will be raised.
:param command: the commad (
as a string list) to run the browser
:param minidump_dir: a path where to extract minidumps
in case the
browser hang. This have to be the same value
used
in `mozcrash.check_for_crashes`.
:param timeout:
if specified, timeout to wait
for the browser before
we
raise a :
class:`TalosError`
:param on_started: a callback that can be used to do things just after
the browser has been started. The callback must takes
an argument, which
is the psutil.Process instance
:param kwargs: additional keyword arguments
for the :
class:`subprocess.Popen`
instance
Returns a ProcessContext instance,
with available output
and pid used.
"""
debugger_info = find_debugger_info(debug, debugger, debugger_args)
if debugger_info
is not None:
return run_in_debug_mode(
command, debugger_info, on_started=on_started, env=kwargs.get(
"env")
)
is_launcher = sys.platform.startswith(
"win")
and "-wait-for-browser" in command
context = ProcessContext(is_launcher)
first_time = int(time.time()) * 1000
wait_for_quit_timeout = 20
reader = Reader()
LOG.info(
"Using env: %s" % pprint.pformat(kwargs[
"env"]))
timed_out =
False
def timeout_handler():
nonlocal timed_out
timed_out =
True
proc_timer = Timer(timeout, timeout_handler)
proc_timer.start()
proc = subprocess.Popen(
command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=
False, **kwargs
)
reader.proc = proc
LOG.process_start(proc.pid,
" ".join(command))
try:
context.process = psutil.Process(proc.pid)
if on_started:
on_started(context.process)
# read output until the browser terminates or the timeout is hit
for line
in proc.stdout:
reader(line)
if timed_out:
LOG.info(
"Timeout waiting for test completion; killing browser...")
# try to extract the minidump stack if the browser hangs
dump_screen_on_failure(utility_path)
kill_and_get_minidump(context, minidump_dir)
raise TalosError(
"timeout")
break
if reader.got_end_timestamp:
proc.wait(wait_for_quit_timeout)
if proc.poll()
is None:
LOG.info(
"Browser shutdown timed out after {0} seconds, killing"
" process.".format(wait_for_quit_timeout)
)
dump_screen_on_failure(utility_path)
kill_and_get_minidump(context, minidump_dir)
raise TalosError(
"Browser shutdown timed out after {0} seconds, killed"
" process.".format(wait_for_quit_timeout)
)
elif reader.got_timeout:
dump_screen_on_failure(utility_path)
raise TalosError(
"TIMEOUT: %s" % reader.timeout_message)
elif reader.got_error:
dump_screen_on_failure(utility_path)
raise TalosError(
"unexpected error")
finally:
# this also handle KeyboardInterrupt
# ensure early the process is really terminated
proc_timer.cancel()
return_code =
None
try:
return_code = context.kill_process()
if return_code
is None:
return_code = proc.wait(1)
except Exception:
# Maybe killed by kill_and_get_minidump(), maybe ended?
LOG.info(
"Unable to kill process")
LOG.info(traceback.format_exc())
reader.output.append(
"__startBeforeLaunchTimestamp%d__endBeforeLaunchTimestamp" % first_time
)
reader.output.append(
"__startAfterTerminationTimestamp%d__endAfterTerminationTimestamp"
% (int(time.time()) * 1000)
)
if return_code
is not None:
LOG.process_exit(proc.pid, return_code)
else:
LOG.debug(
"Unable to detect exit code of the process %s." % proc.pid)
context.output = reader.output
return context
def find_debugger_info(debug, debugger, debugger_args):
debuggerInfo =
None
if debug
or debugger
or debugger_args:
import mozdebug
if not debugger:
# No debugger name was provided. Look for the default ones on
# current OS.
debugger = mozdebug.get_default_debugger_name(
mozdebug.DebuggerSearch.KeepLooking
)
debuggerInfo =
None
if debugger:
debuggerInfo = mozdebug.get_debugger_info(debugger, debugger_args)
if debuggerInfo
is None:
raise TalosError(
"Could not find a suitable debugger in your PATH.")
return debuggerInfo
def run_in_debug_mode(command, debugger_info, on_started=
None, env=
None):
signal.signal(signal.SIGINT,
lambda sigid, frame:
None)
context = ProcessContext()
command_under_dbg = [debugger_info.path] + debugger_info.args + command
ttest_process = subprocess.Popen(command_under_dbg, env=env)
context.process = psutil.Process(ttest_process.pid)
if on_started:
on_started(context.process)
return_code = ttest_process.wait()
if return_code
is not None:
LOG.process_exit(ttest_process.pid, return_code)
else:
LOG.debug(
"Unable to detect exit code of the process %s." % ttest_process.pid)
return context
def kill_and_get_minidump(context, minidump_dir):
proc = context.process
if context.is_launcher:
kids = context.process.children()
if len(kids) == 1:
LOG.debug(
(
"Launcher process {} detected. Killing parent"
" process {} instead."
).format(proc, kids[0])
)
proc = kids[0]
LOG.debug(
"Killing %s and writing a minidump file" % proc)
mozcrash.kill_and_get_minidump(proc.pid, minidump_dir)
def dump_screen_on_failure(utility_path):
if utility_path
is not None:
dump_screen(utility_path, LOG)
