Give the possibility of placing a custom annotated_steps in tools inside the package.

annotated_steps.py

 #!/usr/bin/python
 
 # Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import imp
 import os
 import re
 import shutil
+import shlex
 import subprocess
 import sys
 import tempfile
 import zipfile
 
 import config_parser
 
 # We expect the tools directory from the dart repo to be checked out into:
 # ../../tools
 DART_DIR = os.path.abspath(
@@ skipping 53 matching lines @@
                    builder_pattern.group(4),
                    is_repo,
                    is_sample)
 
 class BuildStep(object):
   """
   A context manager for handling build steps.
 
   When the context manager is entered, it prints the "@@@BUILD_STEP __@@@"
   message. If it exits from an error being raised it displays the
-  "@@@STEP_FAILURE@@@" message.
+  "@@@STEP_FAILURE __@@@" message.
 
   If swallow_error is True, then this will catch and discard any OSError that
   is thrown. This lets you run later BuildSteps if the current one fails.
   """
   def __init__(self, name, swallow_error=False):
     self.name = name
     self.swallow_error = swallow_error
 
   def __enter__(self):
     print '@@@BUILD_STEP %s@@@' % self.name
     sys.stdout.flush()
 
   def __exit__(self, type, value, traceback):
     if value:
-      print '@@@STEP_FAILURE@@@'
+      print '@@@STEP_FAILURE %s@@@' % self.name
       sys.stdout.flush()
       if self.swallow_error and isinstance(value, OSError):
         return True
 
 class TempDir(object):
   def __init__(self, prefix=''):
     self._temp_dir = None
     self._prefix = prefix
 
   def __enter__(self):
@@ skipping 41 matching lines @@
     args = [sys.executable, 'tools/build.py',
             '-mrelease,debug', '--arch=ia32',
             'create_sdk']
     RunProcess(args)
 
 def GetSDK(bot_info):
   with BuildStep('Get sdk'):
     namer = bot_utils.GCSNamer(channel=bot_utils.Channel.DEV)
     # TODO(ricow): Be smarter here, only download if new.
     build_root = GetBuildRoot(bot_info)
-    SafeDelete(os.path.join(build_root, 'dart-sdk'))
+    SafeDelete(os.path.join(build_root, 'dart-sdk'), bot_info)
     if not os.path.exists(build_root):
       os.makedirs(build_root)
     local_zip = os.path.join(build_root, 'sdk.zip')
     gsutils = bot_utils.GSUtil()
     gsutils.execute(['cp',
                     namer.sdk_zipfilepath('latest', bot_info.system,
                                           'ia32', 'release'),
                     local_zip])
     if bot_info.system == 'windows':
       with zipfile.ZipFile(local_zip, 'r') as zip_file:
         zip_file.extractall(path=build_root)
     else:
       # We don't keep the execution bit if we use python's zipfile on possix.
       RunProcess(['unzip', local_zip, '-d', build_root])
 
 def GetPackagePath(bot_info):
   if bot_info.is_repo:
     return os.path.join('pkg', bot_info.package_name)
   return os.path.join('third_party', 'pkg', bot_info.package_name)
 
 def GetBuildRoot(bot_info):
   system = bot_info.system
   if system == 'windows':
     system = 'win32'
   if system == 'mac':
     system = 'macos'
   return utils.GetBuildRoot(system, mode='release', arch='ia32',
                             target_os=system)
 
-def SafeDelete(path):
+def SafeDelete(path, bot_info):
   if bot_info.system == 'windows':
     if os.path.exists(path):
       args = ['cmd.exe', '/c', 'rmdir', '/q', '/s', path]
       RunProcess(args)
   else:
     shutil.rmtree(path, ignore_errors=True)
 
 
 def GetPackageCopy(bot_info):
   build_root = GetBuildRoot(bot_info)
   package_copy = os.path.join(build_root, 'package_copy')
   package_path = GetPackagePath(bot_info)
   copy_path = os.path.join(package_copy, bot_info.package_name)
-  SafeDelete(package_copy)
+  SafeDelete(package_copy, bot_info)
   no_git = shutil.ignore_patterns('.git')
   shutil.copytree(package_path, copy_path, symlinks=False, ignore=no_git)
   return copy_path
 
-def GetSdkBin():
+def GetSdkBin(bot_info):
   return os.path.join(os.getcwd(), GetBuildRoot(bot_info),
                       'dart-sdk', 'bin')
 
-def GetVM():
+def GetVM(bot_info):
   executable = 'dart.exe' if bot_info.system == 'windows' else 'dart'
-  return os.path.join(GetSdkBin(), executable)
+  return os.path.join(DART_DIR, 'tools/testing/bin', bot_info.system, executable)

[ricow1, 2015/05/19 13:38:09]

long line

[sigurdm, 2015/05/19 13:39:50]

Done.

 
 def GetPub(bot_info):
   executable = 'pub.bat' if bot_info.system == 'windows' else 'pub'
-  return os.path.join(GetSdkBin(), executable)
+  return os.path.join(GetSdkBin(bot_info), executable)
 
 def GetPubEnv(bot_info):
   return {'PUB_CACHE' : os.path.join(os.getcwd(),
       GetBuildRoot(bot_info), 'pub_cache') }
 
 # _RunPubCacheRepair and _CheckPubCacheCorruption are not used right now, but we
 # keep them around because they provide an easy way to diagnose and fix issues
 # in the bots.
 def _RunPubCacheRepair(bot_info, path):
   pub = GetPub(bot_info)
@@ skipping 102 matching lines @@
   system = bot_info.system
   xvfb_command = ['xvfb-run', '-a', '--server-args=-screen 0 1024x768x24']
   xvfb_args =  xvfb_command if system == 'linux' else []
   suffix = ' under build' if folder == 'build/test' else ''
   with BuildStep('Test vm release mode%s' % suffix, swallow_error=True):
     args = [sys.executable, 'tools/test.py',
             '-mrelease', '-rvm', '-cnone'] + standard_args
     args.extend(LogsArgument())
     # For easy integration testing we give access to the sdk bin directory.
     # This only makes sense on vm testing.
-    extra_env = { 'DART_SDK_BIN' : GetSdkBin() }
+    extra_env = { 'DART_SDK_BIN' : GetSdkBin(bot_info) }
     RunProcess(args, extra_env=extra_env)
   with BuildStep('Test analyzer%s' % suffix, swallow_error=True):
     args = [sys.executable, 'tools/test.py',
             '-mrelease', '-rnone', '-cdart2analyzer'] + standard_args
     args.extend(LogsArgument())
     RunProcess(args)
   if bot_info.system != 'windows':
     with BuildStep('Test dartium%s' % suffix, swallow_error=True):
       test_args = [sys.executable, 'tools/test.py',
                    '-mrelease', '-rdartium', '-cnone', '-j4']
       args = xvfb_args + test_args + standard_args
       args.extend(LogsArgument())
       RunProcess(args)
 
   for runtime in JS_RUNTIMES[system]:
     with BuildStep('dart2js-%s%s' % (runtime, suffix), swallow_error=True):
       test_args = [sys.executable, 'tools/test.py',
                    '-mrelease', '-r%s' % runtime, '-cdart2js', '-j4',
                    '--dart2js-batch']
       args = xvfb_args + test_args + standard_args
       args.extend(LogsArgument())
       RunProcess(args)
 
+def FillMagicMarkers(v, replacements):
+  def replace(match):
+    word = match.group(1)
+    if not word in replacements:
+      raise Exception("Unknown magic marker %s. Known mappings are: %s" %
+                      (word, replacements))
+    return replacements[word]
+  return re.sub(r"\$(\w+)", replace, v)
 
-def RunHooks(hooks, section_name):
+# Runs the script given by test_config.get_config if it exists, does nothing
+# otherwise.
+# Returns `True` if the script was run.
+def RunCustomScript(test_config):
+  custom_script = test_config.get_custom_script()
+  if custom_script:
+    command_string = FillMagicMarkers(custom_script, test_config.replacements)
+    with BuildStep('Running custom script %s' % command_string,
+                   swallow_error=True):
+      args = shlex.split(command_string, posix=True)
+      sys.stdout.flush()
+      exit_code = subprocess.call(args)
+      if exit_code != 0:
+        print "Custom script failed"
+    return True
+  else:
+    return False
+
+
+def RunHooks(hooks, section_name, replacements):
   for name, command in hooks.iteritems():
+    command = FillMagicMarkers(command, replacements)
     with BuildStep('%s: %s' % (section_name, name), swallow_error=True):
       RunProcess(command, shell=True)
 
 def RunPrePubUpgradeHooks(test_config):
-  RunHooks(test_config.get_pre_pub_upgrade_hooks(), "Pre pub upgrade hooks")
+  RunHooks(test_config.get_pre_pub_upgrade_hooks(), "Pre pub upgrade hooks",
+           test_config.replacements)
 
 def RunPrePubBuildHooks(test_config):
-  RunHooks(test_config.get_pre_pub_build_hooks(), "Pre pub build hooks")
+  RunHooks(test_config.get_pre_pub_build_hooks(), "Pre pub build hooks",
+           test_config.replacements)
 
 def RunPostPubBuildHooks(test_config):
-  RunHooks(test_config.get_post_pub_build_hooks(), "Pre pub build hooks")
+  RunHooks(test_config.get_post_pub_build_hooks(), "Pre pub build hooks",
+           test_config.replacements)
 
 def RunPreTestHooks(test_config):
-  RunHooks(test_config.get_pre_test_hooks(), "Pre test hooks")
+  RunHooks(test_config.get_pre_test_hooks(), "Pre test hooks",
+           test_config.replacements)
 
 def RunPostTestHooks(test_config):
   RunHooks(test_config.get_post_test_hooks(), "Post test hooks")
 
-if __name__ == '__main__':
+def main():
   bot_info = GetBotInfo()
+
   print 'Bot info: %s' % bot_info
   copy_path = GetPackageCopy(bot_info)
   config_file = os.path.join(copy_path, '.test_config')
-  test_config = config_parser.ConfigParser(config_file,
-                                           GetVM(),
-                                           copy_path)
-  GetSDK(bot_info)
-  print 'Running testing in copy of package in %s' % copy_path
-  RunPrePubUpgradeHooks(test_config)
-  RunPubUpgrade(bot_info, copy_path)
+  test_config = config_parser.ConfigParser(config_file)
+  test_config.replacements = {
+    'dart': GetVM(bot_info),
+    'project_root': copy_path,
+    'python': sys.executable
+  }
 
-  RunPrePubBuildHooks(test_config)
-  RunPubBuild(bot_info, copy_path, 'web')
-  RunPubBuild(bot_info, copy_path, 'test', 'debug')
-  RunPostPubBuildHooks(test_config)
-  FixupTestControllerJS(copy_path)
+  if not RunCustomScript(test_config):
+    print "No custom script found, running default steps."
 
-  RunPreTestHooks(test_config)
-  RunPackageTesting(bot_info, copy_path, 'test')
-  RunPackageTesting(bot_info, copy_path, 'build/test')
-  RunPostTestHooks(test_config)
+    GetSDK(bot_info)
+    print 'Running testing in copy of package in %s' % copy_path
+    RunPrePubUpgradeHooks(test_config)
+    RunPubUpgrade(bot_info, copy_path)
+
+    RunPrePubBuildHooks(test_config)
+    RunPubBuild(bot_info, copy_path, 'web')
+    RunPubBuild(bot_info, copy_path, 'test', 'debug')
+    RunPostPubBuildHooks(test_config)
+    FixupTestControllerJS(copy_path)
+
+    RunPreTestHooks(test_config)
+    RunPackageTesting(bot_info, copy_path, 'test')
+    RunPackageTesting(bot_info, copy_path, 'build/test')
+    RunPostTestHooks(test_config)
+
+if __name__ == '__main__':
+  main()