| #!/usr/bin/python |
| |
| # Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Dart2js buildbot steps |
| |
| Runs tests for the dart2js compiler. |
| """ |
| |
| import platform |
| import optparse |
| import os |
| import re |
| import shutil |
| import subprocess |
| import sys |
| |
| BUILDER_NAME = 'BUILDBOT_BUILDERNAME' |
| BUILDER_CLOBBER = 'BUILDBOT_CLOBBER' |
| |
| |
| DART_PATH = os.path.dirname( |
| os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
| |
| DART2JS_BUILDER = ( |
| r'dart2js-(linux|mac|windows)(-(jsshell))?-(debug|release)(-(checked|host-checked))?(-(host-checked))?-?(\d*)-?(\d*)') |
| WEB_BUILDER = ( |
| r'dart2js-(ie|ff|safari|chrome|opera)-(win7|win8|mac|linux)(-(all|html))?') |
| |
| NO_COLOR_ENV = dict(os.environ) |
| NO_COLOR_ENV['TERM'] = 'nocolor' |
| |
| class BuildInfo(object): |
| """ Encapsulation of build information. |
| - compiler: 'dart2js' or None when the builder has an incorrect name |
| - runtime: 'd8', 'ie', 'ff', 'safari', 'chrome', 'opera' |
| - mode: 'debug' or 'release' |
| - system: 'linux', 'mac', or 'win7' |
| - checked: True if we should run in checked mode, otherwise False |
| - host_checked: True if we should run in host checked mode, otherwise False |
| - shard_index: The shard we are running, None when not specified. |
| - total_shards: The total number of shards, None when not specified. |
| - is_buildbot: True if we are on a buildbot (or emulating it). |
| - test_set: Specification of a non standard test set, default None |
| """ |
| def __init__(self, compiler, runtime, mode, system, checked=False, |
| host_checked=False, shard_index=None, total_shards=None, |
| is_buildbot=False, test_set=None): |
| self.compiler = compiler |
| self.runtime = runtime |
| self.mode = mode |
| self.system = system |
| self.checked = checked |
| self.host_checked = host_checked |
| self.shard_index = shard_index |
| self.total_shards = total_shards |
| self.is_buildbot = is_buildbot |
| self.test_set = test_set |
| |
| def PrintBuildInfo(self): |
| shard_description = "" |
| if self.shard_index: |
| shard_description = " shard %s of %s" % (self.shard_index, |
| self.total_shards) |
| print ("compiler: %s, runtime: %s mode: %s, system: %s," |
| " checked: %s, host-checked: %s, test-set: %s%s" |
| ) % (self.compiler, self.runtime, self.mode, self.system, |
| self.checked, self.host_checked, self.test_set, |
| shard_description) |
| |
| |
| def GetBuildInfo(): |
| """Returns a BuildInfo object for the current buildbot based on the |
| name of the builder. |
| """ |
| parser = optparse.OptionParser() |
| parser.add_option('-n', '--name', dest='name', help='The name of the build' |
| 'bot you would like to emulate (ex: web-chrome-win7)', default=None) |
| args, _ = parser.parse_args() |
| |
| compiler = None |
| runtime = None |
| mode = None |
| system = None |
| builder_name = os.environ.get(BUILDER_NAME) |
| checked = False |
| host_checked = False |
| shard_index = None |
| total_shards = None |
| is_buildbot = True |
| test_set = None |
| |
| if not builder_name: |
| # We are not running on a buildbot. |
| is_buildbot = False |
| if args.name: |
| builder_name = args.name |
| else: |
| print 'Use -n $BUILDBOT_NAME for the bot you would like to emulate.' |
| sys.exit(1) |
| |
| if builder_name: |
| dart2js_pattern = re.match(DART2JS_BUILDER, builder_name) |
| web_pattern = re.match(WEB_BUILDER, builder_name) |
| |
| if web_pattern: |
| compiler = 'dart2js' |
| runtime = web_pattern.group(1) |
| system = web_pattern.group(2) |
| mode = 'release' |
| test_set = web_pattern.group(4) |
| elif dart2js_pattern: |
| compiler = 'dart2js' |
| system = dart2js_pattern.group(1) |
| runtime = 'd8' |
| if dart2js_pattern.group(3) == 'jsshell': |
| runtime = 'jsshell' |
| mode = dart2js_pattern.group(4) |
| # The valid naming parts for checked and host-checked are: |
| # Empty: checked=False, host_checked=False |
| # -checked: checked=True, host_checked=False |
| # -host-checked: checked=False, host_checked=True |
| # -checked-host-checked: checked=True, host_checked=True |
| if dart2js_pattern.group(6) == 'checked': |
| checked = True |
| if dart2js_pattern.group(6) == 'host-checked': |
| host_checked = True |
| if dart2js_pattern.group(8) == 'host-checked': |
| host_checked = True |
| shard_index = dart2js_pattern.group(9) |
| total_shards = dart2js_pattern.group(10) |
| |
| if system == 'windows': |
| system = 'win7' |
| |
| if (system == 'win7' and platform.system() != 'Windows') or ( |
| system == 'mac' and platform.system() != 'Darwin') or ( |
| system == 'linux' and platform.system() != 'Linux'): |
| print ('Error: You cannot emulate a buildbot with a platform different ' |
| 'from your own.') |
| sys.exit(1) |
| return BuildInfo(compiler, runtime, mode, system, checked, host_checked, |
| shard_index, total_shards, is_buildbot, test_set) |
| |
| |
| def NeedsXterm(compiler, runtime): |
| return runtime in ['ie', 'chrome', 'safari', 'opera', 'ff', 'drt'] |
| |
| |
| def TestStepName(name, flags): |
| # Filter out flags with '=' as this breaks the /stats feature of the |
| # build bot. |
| flags = [x for x in flags if not '=' in x] |
| return ('%s tests %s' % (name, ' '.join(flags))).strip() |
| |
| |
| def TestStep(name, mode, system, compiler, runtime, targets, flags): |
| step_name = TestStepName(name, flags) |
| print '@@@BUILD_STEP %s@@@' % step_name |
| sys.stdout.flush() |
| if NeedsXterm(compiler, runtime) and system == 'linux': |
| cmd = ['xvfb-run', '-a'] |
| else: |
| cmd = [] |
| |
| user_test = os.environ.get('USER_TEST', 'no') |
| |
| cmd.extend([sys.executable, |
| os.path.join(os.curdir, 'tools', 'test.py'), |
| '--step_name=' + step_name, |
| '--mode=' + mode, |
| '--compiler=' + compiler, |
| '--runtime=' + runtime, |
| '--time', |
| '--use-sdk', |
| '--report']) |
| |
| if user_test == 'yes': |
| cmd.append('--progress=color') |
| else: |
| cmd.extend(['--progress=buildbot', '-v']) |
| |
| if flags: |
| cmd.extend(flags) |
| cmd.extend(targets) |
| |
| print 'running %s' % (' '.join(cmd)) |
| exit_code = subprocess.call(cmd, env=NO_COLOR_ENV) |
| if exit_code != 0: |
| print '@@@STEP_FAILURE@@@' |
| return exit_code |
| |
| |
| def BuildSDK(mode, system): |
| """ build the SDK. |
| Args: |
| - mode: either 'debug' or 'release' |
| - system: either 'linux', 'mac', or 'win7' |
| """ |
| os.chdir(DART_PATH) |
| |
| args = [sys.executable, './tools/build.py', '--mode=' + mode, 'create_sdk'] |
| print 'running %s' % (' '.join(args)) |
| return subprocess.call(args, env=NO_COLOR_ENV) |
| |
| |
| def TestCompiler(runtime, mode, system, flags, is_buildbot, test_set): |
| """ test the compiler. |
| Args: |
| - runtime: either 'd8', 'jsshell', or one of the browsers, see GetBuildInfo |
| - mode: either 'debug' or 'release' |
| - system: either 'linux', 'mac', or 'win7' |
| - flags: extra flags to pass to test.dart |
| - is_buildbot: true if we are running on a real buildbot instead of |
| emulating one. |
| - test_set: Specification of a non standard test set, default None |
| """ |
| |
| # Make sure we are in the dart directory |
| os.chdir(DART_PATH) |
| |
| if system.startswith('win') and runtime == 'ie': |
| # There should not be more than one InternetExplorerDriver instance |
| # running at a time. For details, see |
| # http://code.google.com/p/selenium/wiki/InternetExplorerDriver. |
| flags += ['-j1'] |
| |
| def GetPath(runtime): |
| """ Helper to get the path to the Chrome or Firefox executable for a |
| particular platform on the buildbot. Throws a KeyError if runtime is not |
| either 'chrome' or 'ff'.""" |
| if system == 'mac': |
| partDict = {'chrome': 'Google\\ Chrome', 'ff': 'Firefox'} |
| mac_path = '/Applications/%s.app/Contents/MacOS/%s' |
| path_dict = {'chrome': mac_path % (partDict[runtime], partDict[runtime]), |
| 'ff': mac_path % (partDict[runtime], partDict[runtime].lower())} |
| elif system == 'linux': |
| path_dict = {'ff': 'firefox', 'chrome': 'google-chrome'} |
| else: |
| # Windows. |
| path_dict = {'ff': os.path.join('C:/', 'Program Files (x86)', |
| 'Mozilla Firefox', 'firefox.exe'), |
| 'chrome': os.path.join('C:/', 'Users', 'chrome-bot', 'AppData', |
| 'Local', 'Google', 'Chrome', 'Application', 'chrome.exe')} |
| return path_dict[runtime] |
| |
| if system == 'linux' and runtime == 'chrome': |
| # TODO(ngeoffray): We should install selenium on the buildbot. |
| runtime = 'drt' |
| elif (runtime == 'ff' or runtime == 'chrome') and is_buildbot: |
| # Print out browser version numbers if we're running on the buildbot (where |
| # we know the paths to these browser installations). |
| version_query_string = '"%s" --version' % GetPath(runtime) |
| if runtime == 'ff' and system == 'win7': |
| version_query_string += '| more' |
| elif runtime == 'chrome' and system == 'win7': |
| version_query_string = ('''reg query "HKCU\\Software\\Microsoft\\''' + |
| '''Windows\\CurrentVersion\\Uninstall\\Google Chrome" /v Version''') |
| p = subprocess.Popen(version_query_string, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) |
| output, stderr = p.communicate() |
| output = output.split() |
| try: |
| print 'Version of %s: %s' % (runtime, output[-1]) |
| except IndexError: |
| # Failed to obtain version information. Continue running tests. |
| pass |
| |
| if runtime == 'd8': |
| # The dart2js compiler isn't self-hosted (yet) so we run its |
| # unit tests on the VM. We avoid doing this on the builders |
| # that run the browser tests to cut down on the cycle time. |
| TestStep("dart2js_unit", mode, system, 'none', 'vm', ['dart2js'], flags) |
| |
| if not (system.startswith('win') and runtime == 'ie'): |
| # Run the default set of test suites. |
| TestStep("dart2js", mode, system, 'dart2js', runtime, [], flags) |
| |
| # TODO(kasperl): Consider running peg and css tests too. |
| extras = ['dart2js_extra', 'dart2js_native', 'dart2js_foreign'] |
| TestStep("dart2js_extra", mode, system, 'dart2js', runtime, extras, flags) |
| else: |
| # TODO(ricow): Enable standard sharding for IE bots when we have more vms. |
| if test_set == 'html': |
| TestStep("dart2js", mode, system, 'dart2js', runtime, ['html'], flags) |
| elif test_set == 'all': |
| TestStep("dart2js", mode, system, 'dart2js', runtime, ['dartc', |
| 'samples', 'standalone', 'corelib', 'co19', 'language', 'isolate', |
| 'vm', 'json', 'benchmark_smoke', 'dartdoc', 'utils', 'pub', 'lib'], |
| flags) |
| extras = ['dart2js_extra', 'dart2js_native', 'dart2js_foreign'] |
| TestStep("dart2js_extra", mode, system, 'dart2js', runtime, extras, |
| flags) |
| |
| return 0 |
| |
| def _DeleteFirefoxProfiles(directory): |
| """Find all the firefox profiles in a particular directory and delete them.""" |
| for f in os.listdir(directory): |
| item = os.path.join(directory, f) |
| if os.path.isdir(item) and f.startswith('tmp'): |
| subprocess.Popen('rm -rf %s' % item, shell=True) |
| |
| def CleanUpTemporaryFiles(system, browser): |
| """For some browser (selenium) tests, the browser creates a temporary profile |
| on each browser session start. On Windows, generally these files are |
| automatically deleted when all python processes complete. However, since our |
| buildbot slave script also runs on python, we never get the opportunity to |
| clear out the temp files, so we do so explicitly here. Our batch browser |
| testing will make this problem occur much less frequently, but will still |
| happen eventually unless we do this. |
| |
| This problem also occurs with batch tests in Firefox. For some reason selenium |
| automatically deletes the temporary profiles for Firefox for one browser, |
| but not multiple ones when we have many open batch tasks running. This |
| behavior has not been reproduced outside of the buildbots. |
| |
| Args: |
| - system: either 'linux', 'mac', or 'win7' |
| - browser: one of the browsers, see GetBuildInfo |
| """ |
| if system == 'win7': |
| shutil.rmtree('C:\\Users\\chrome-bot\\AppData\\Local\\Temp', |
| ignore_errors=True) |
| elif browser == 'ff': |
| # Note: the buildbots run as root, so we can do this without requiring a |
| # password. The command won't actually work on regular machines without |
| # root permissions. |
| _DeleteFirefoxProfiles('/tmp') |
| _DeleteFirefoxProfiles('/var/tmp') |
| |
| def ClobberBuilder(mode): |
| """ Clobber the builder before we do the build. |
| Args: |
| - mode: either 'debug' or 'release' |
| """ |
| cmd = [sys.executable, |
| './tools/clean_output_directory.py', |
| '--mode=' + mode] |
| print 'Clobbering %s' % (' '.join(cmd)) |
| return subprocess.call(cmd, env=NO_COLOR_ENV) |
| |
| def GetShouldClobber(): |
| return os.environ.get(BUILDER_CLOBBER) == "1" |
| |
| def GetHasHardCodedCheckedMode(build_info): |
| # TODO(ricow): We currently run checked mode tests on chrome on linux and |
| # on the slow (all) IE windows bots. This is a hack and we should use the |
| # normal sharding and checked splitting functionality when we get more |
| # vms for testing this. |
| if (build_info.system == 'linux' and build_info.runtime == 'chrome'): |
| return True |
| if (build_info.system == 'win7' and build_info.runtime == 'ie' and |
| build_info.test_set == 'all'): |
| return True |
| return False |
| |
| def main(): |
| if len(sys.argv) == 0: |
| print 'Script pathname not known, giving up.' |
| return 1 |
| |
| build_info = GetBuildInfo() |
| |
| # Print out the buildinfo for easy debugging. |
| build_info.PrintBuildInfo() |
| |
| if build_info.compiler is None: |
| return 1 |
| |
| if GetShouldClobber(): |
| print '@@@BUILD_STEP Clobber@@@' |
| status = ClobberBuilder(build_info.mode) |
| if status != 0: |
| print '@@@STEP_FAILURE@@@' |
| return status |
| |
| print '@@@BUILD_STEP build sdk@@@' |
| status = BuildSDK(build_info.mode, build_info.system) |
| if status != 0: |
| print '@@@STEP_FAILURE@@@' |
| return status |
| |
| test_flags = [] |
| if build_info.shard_index: |
| test_flags = ['--shards=%s' % build_info.total_shards, |
| '--shard=%s' % build_info.shard_index] |
| |
| if build_info.checked: test_flags += ['--checked'] |
| |
| if build_info.host_checked: test_flags += ['--host-checked'] |
| |
| status = TestCompiler(build_info.runtime, build_info.mode, |
| build_info.system, list(test_flags), |
| build_info.is_buildbot, build_info.test_set) |
| |
| # See comment in GetHasHardCodedCheckedMode, this is a hack. |
| if (status == 0 and GetHasHardCodedCheckedMode(build_info)): |
| status = TestCompiler(build_info.runtime, build_info.mode, |
| build_info.system, |
| test_flags + ['--checked'], |
| build_info.is_buildbot, |
| build_info.test_set) |
| |
| if build_info.runtime != 'd8': CleanUpTemporaryFiles(build_info.system, |
| build_info.runtime) |
| if status != 0: print '@@@STEP_FAILURE@@@' |
| return status |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |
