Home | History | Annotate | Download | only in browsertester 
      1 #!/usr/bin/python
      2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
      3 # Use of this source code is governed by a BSD-style license that can be
      4 # found in the LICENSE file.
      5 
      6 import os.path
      7 import re
      8 import shutil
      9 import sys
     10 import tempfile
     11 import time
     12 import urlparse
     13 
     14 import browserprocess
     15 
     16 class LaunchFailure(Exception):
     17   pass
     18 
     19 
     20 def GetPlatform():
     21   if sys.platform == 'darwin':
     22     platform = 'mac'
     23   elif sys.platform.startswith('linux'):
     24     platform = 'linux'
     25   elif sys.platform in ('cygwin', 'win32'):
     26     platform = 'windows'
     27   else:
     28     raise LaunchFailure('Unknown platform: %s' % sys.platform)
     29   return platform
     30 
     31 
     32 PLATFORM = GetPlatform()
     33 
     34 
     35 def SelectRunCommand():
     36   # The subprocess module added support for .kill in Python 2.6
     37   assert (sys.version_info[0] >= 3 or (sys.version_info[0] == 2 and
     38                                        sys.version_info[1] >= 6))
     39   if PLATFORM == 'linux':
     40     return browserprocess.RunCommandInProcessGroup
     41   else:
     42     return browserprocess.RunCommandWithSubprocess
     43 
     44 
     45 RunCommand = SelectRunCommand()
     46 
     47 def RemoveDirectory(path):
     48   retry = 5
     49   sleep_time = 0.25
     50   while True:
     51     try:
     52       shutil.rmtree(path)
     53     except Exception:
     54       # Windows processes sometime hang onto files too long
     55       if retry > 0:
     56         retry -= 1
     57         time.sleep(sleep_time)
     58         sleep_time *= 2
     59       else:
     60         # No luck - don't mask the error
     61         raise
     62     else:
     63       # succeeded
     64       break
     65 
     66 
     67 
     68 # In Windows, subprocess seems to have an issue with file names that
     69 # contain spaces.
     70 def EscapeSpaces(path):
     71   if PLATFORM == 'windows' and ' ' in path:
     72     return '"%s"' % path
     73   return path
     74 
     75 
     76 def MakeEnv(options):
     77   env = dict(os.environ)
     78   # Enable PPAPI Dev interfaces for testing.
     79   env['NACL_ENABLE_PPAPI_DEV'] = str(options.enable_ppapi_dev)
     80   if options.debug:
     81     env['NACL_PLUGIN_DEBUG'] = '1'
     82     # env['NACL_SRPC_DEBUG'] = '1'
     83   return env
     84 
     85 
     86 class BrowserLauncher(object):
     87 
     88   WAIT_TIME = 20
     89   WAIT_STEPS = 80
     90   SLEEP_TIME = float(WAIT_TIME) / WAIT_STEPS
     91 
     92   def __init__(self, options):
     93     self.options = options
     94     self.profile = None
     95     self.binary = None
     96     self.tool_log_dir = None
     97 
     98   def KnownPath(self):
     99     raise NotImplementedError
    100 
    101   def BinaryName(self):
    102     raise NotImplementedError
    103 
    104   def CreateProfile(self):
    105     raise NotImplementedError
    106 
    107   def MakeCmd(self, url, host, port):
    108     raise NotImplementedError
    109 
    110   def CreateToolLogDir(self):
    111     self.tool_log_dir = tempfile.mkdtemp(prefix='vglogs_')
    112     return self.tool_log_dir
    113 
    114   def FindBinary(self):
    115     if self.options.browser_path:
    116       return self.options.browser_path
    117     else:
    118       path = self.KnownPath()
    119       if path is None or not os.path.exists(path):
    120         raise LaunchFailure('Cannot find the browser directory')
    121       binary = os.path.join(path, self.BinaryName())
    122       if not os.path.exists(binary):
    123         raise LaunchFailure('Cannot find the browser binary')
    124       return binary
    125 
    126   def WaitForProcessDeath(self):
    127     self.browser_process.Wait(self.WAIT_STEPS, self.SLEEP_TIME)
    128 
    129   def Cleanup(self):
    130     self.browser_process.Kill()
    131 
    132     RemoveDirectory(self.profile)
    133     if self.tool_log_dir is not None:
    134       RemoveDirectory(self.tool_log_dir)
    135 
    136   def MakeProfileDirectory(self):
    137     self.profile = tempfile.mkdtemp(prefix='browserprofile_')
    138     return self.profile
    139 
    140   def SetStandardStream(self, env, var_name, redirect_file, is_output):
    141     if redirect_file is None:
    142       return
    143     file_prefix = 'file:'
    144     dev_prefix = 'dev:'
    145     debug_warning = 'DEBUG_ONLY:'
    146     # logic must match src/trusted/service_runtime/nacl_resource.*
    147     # resource specification notation.  file: is the default
    148     # interpretation, so we must have an exhaustive list of
    149     # alternative schemes accepted.  if we remove the file-is-default
    150     # interpretation, replace with
    151     #   is_file = redirect_file.startswith(file_prefix)
    152     # and remove the list of non-file schemes.
    153     is_file = (not (redirect_file.startswith(dev_prefix) or
    154                     redirect_file.startswith(debug_warning + dev_prefix)))
    155     if is_file:
    156       if redirect_file.startswith(file_prefix):
    157         bare_file = redirect_file[len(file_prefix)]
    158       else:
    159         bare_file = redirect_file
    160       # why always abspath?  does chrome chdir or might it in the
    161       # future?  this means we do not test/use the relative path case.
    162       redirect_file = file_prefix + os.path.abspath(bare_file)
    163     else:
    164       bare_file = None  # ensure error if used without checking is_file
    165     env[var_name] = redirect_file
    166     if is_output:
    167       # sel_ldr appends program output to the file so we need to clear it
    168       # in order to get the stable result.
    169       if is_file:
    170         if os.path.exists(bare_file):
    171           os.remove(bare_file)
    172         parent_dir = os.path.dirname(bare_file)
    173         # parent directory may not exist.
    174         if not os.path.exists(parent_dir):
    175           os.makedirs(parent_dir)
    176 
    177   def Launch(self, cmd, env):
    178     browser_path = cmd[0]
    179     if not os.path.exists(browser_path):
    180       raise LaunchFailure('Browser does not exist %r'% browser_path)
    181     if not os.access(browser_path, os.X_OK):
    182       raise LaunchFailure('Browser cannot be executed %r (Is this binary on an '
    183                           'NFS volume?)' % browser_path)
    184     if self.options.sel_ldr:
    185       env['NACL_SEL_LDR'] = self.options.sel_ldr
    186     if self.options.sel_ldr_bootstrap:
    187       env['NACL_SEL_LDR_BOOTSTRAP'] = self.options.sel_ldr_bootstrap
    188     if self.options.irt_library:
    189       env['NACL_IRT_LIBRARY'] = self.options.irt_library
    190     self.SetStandardStream(env, 'NACL_EXE_STDIN',
    191                            self.options.nacl_exe_stdin, False)
    192     self.SetStandardStream(env, 'NACL_EXE_STDOUT',
    193                            self.options.nacl_exe_stdout, True)
    194     self.SetStandardStream(env, 'NACL_EXE_STDERR',
    195                            self.options.nacl_exe_stderr, True)
    196     print 'ENV:', ' '.join(['='.join(pair) for pair in env.iteritems()])
    197     print 'LAUNCHING: %s' % ' '.join(cmd)
    198     sys.stdout.flush()
    199     self.browser_process = RunCommand(cmd, env=env)
    200 
    201   def IsRunning(self):
    202     return self.browser_process.IsRunning()
    203 
    204   def GetReturnCode(self):
    205     return self.browser_process.GetReturnCode()
    206 
    207   def Run(self, url, host, port):
    208     self.binary = EscapeSpaces(self.FindBinary())
    209     self.profile = self.CreateProfile()
    210     if self.options.tool is not None:
    211       self.tool_log_dir = self.CreateToolLogDir()
    212     cmd = self.MakeCmd(url, host, port)
    213     self.Launch(cmd, MakeEnv(self.options))
    214 
    215 
    216 def EnsureDirectory(path):
    217   if not os.path.exists(path):
    218     os.makedirs(path)
    219 
    220 
    221 def EnsureDirectoryForFile(path):
    222   EnsureDirectory(os.path.dirname(path))
    223 
    224 
    225 class ChromeLauncher(BrowserLauncher):
    226 
    227   def KnownPath(self):
    228     if PLATFORM == 'linux':
    229       # TODO(ncbray): look in path?
    230       return '/opt/google/chrome'
    231     elif PLATFORM == 'mac':
    232       return '/Applications/Google Chrome.app/Contents/MacOS'
    233     else:
    234       homedir = os.path.expanduser('~')
    235       path = os.path.join(homedir, r'AppData\Local\Google\Chrome\Application')
    236       return path
    237 
    238   def BinaryName(self):
    239     if PLATFORM == 'mac':
    240       return 'Google Chrome'
    241     elif PLATFORM == 'windows':
    242       return 'chrome.exe'
    243     else:
    244       return 'chrome'
    245 
    246   def MakeEmptyJSONFile(self, path):
    247     EnsureDirectoryForFile(path)
    248     f = open(path, 'w')
    249     f.write('{}')
    250     f.close()
    251 
    252   def CreateProfile(self):
    253     profile = self.MakeProfileDirectory()
    254 
    255     # Squelch warnings by creating bogus files.
    256     self.MakeEmptyJSONFile(os.path.join(profile, 'Default', 'Preferences'))
    257     self.MakeEmptyJSONFile(os.path.join(profile, 'Local State'))
    258 
    259     return profile
    260 
    261   def NetLogName(self):
    262     return os.path.join(self.profile, 'netlog.json')
    263 
    264   def MakeCmd(self, url, host, port):
    265     cmd = [self.binary,
    266             # --enable-logging enables stderr output from Chromium subprocesses
    267             # on Windows (see
    268             # https://code.google.com/p/chromium/issues/detail?id=171836)
    269             '--enable-logging',
    270             '--disable-web-resources',
    271             '--disable-preconnect',
    272             # This is speculative, sync should not occur with a clean profile.
    273             '--disable-sync',
    274             # This prevents Chrome from making "hidden" network requests at
    275             # startup.  These requests could be a source of non-determinism,
    276             # and they also add noise to the netlogs.
    277             '--dns-prefetch-disable',
    278             '--no-first-run',
    279             '--no-default-browser-check',
    280             '--log-level=1',
    281             '--safebrowsing-disable-auto-update',
    282             '--disable-default-apps',
    283             # Suppress metrics reporting.  This prevents misconfigured bots,
    284             # people testing at their desktop, etc from poisoning the UMA data.
    285             '--metrics-recording-only',
    286             # Chrome explicitly blacklists some ports as "unsafe" because
    287             # certain protocols use them.  Chrome gives an error like this:
    288             # Error 312 (net::ERR_UNSAFE_PORT): Unknown error
    289             # Unfortunately, the browser tester can randomly choose a
    290             # blacklisted port.  To work around this, the tester whitelists
    291             # whatever port it is using.
    292             '--explicitly-allowed-ports=%d' % port,
    293             '--user-data-dir=%s' % self.profile]
    294     # Log network requests to assist debugging.
    295     cmd.append('--log-net-log=%s' % self.NetLogName())
    296     if PLATFORM == 'linux':
    297       # Explicitly run with mesa on linux. The test infrastructure doesn't have
    298       # sufficient native GL contextes to run these tests.
    299       cmd.append('--use-gl=osmesa')
    300     if self.options.ppapi_plugin is None:
    301       cmd.append('--enable-nacl')
    302       disable_sandbox = False
    303       # Chrome process can't access file within sandbox
    304       disable_sandbox |= self.options.nacl_exe_stdin is not None
    305       disable_sandbox |= self.options.nacl_exe_stdout is not None
    306       disable_sandbox |= self.options.nacl_exe_stderr is not None
    307       if disable_sandbox:
    308         cmd.append('--no-sandbox')
    309     else:
    310       cmd.append('--register-pepper-plugins=%s;%s'
    311                  % (self.options.ppapi_plugin,
    312                     self.options.ppapi_plugin_mimetype))
    313       cmd.append('--no-sandbox')
    314     if self.options.browser_extensions:
    315       cmd.append('--load-extension=%s' %
    316                  ','.join(self.options.browser_extensions))
    317       cmd.append('--enable-experimental-extension-apis')
    318     if self.options.enable_crash_reporter:
    319       cmd.append('--enable-crash-reporter-for-testing')
    320     if self.options.tool == 'memcheck':
    321       cmd = ['src/third_party/valgrind/memcheck.sh',
    322              '-v',
    323              '--xml=yes',
    324              '--leak-check=no',
    325              '--gen-suppressions=all',
    326              '--num-callers=30',
    327              '--trace-children=yes',
    328              '--nacl-file=%s' % (self.options.files[0],),
    329              '--suppressions=' +
    330              '../tools/valgrind/memcheck/suppressions.txt',
    331              '--xml-file=%s/xml.%%p' % (self.tool_log_dir,),
    332              '--log-file=%s/log.%%p' % (self.tool_log_dir,)] + cmd
    333     elif self.options.tool == 'tsan':
    334       cmd = ['src/third_party/valgrind/tsan.sh',
    335              '-v',
    336              '--num-callers=30',
    337              '--trace-children=yes',
    338              '--nacl-file=%s' % (self.options.files[0],),
    339              '--ignore=../tools/valgrind/tsan/ignores.txt',
    340              '--suppressions=../tools/valgrind/tsan/suppressions.txt',
    341              '--log-file=%s/log.%%p' % (self.tool_log_dir,)] + cmd
    342     elif self.options.tool != None:
    343       raise LaunchFailure('Invalid tool name "%s"' % (self.options.tool,))
    344     if self.options.enable_sockets:
    345       cmd.append('--allow-nacl-socket-api=%s' % host)
    346     cmd.extend(self.options.browser_flags)
    347     cmd.append(url)
    348     return cmd
    349