Revert of Bot update cleanup

recipe_modules/bot_update/resources/bot_update.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 # TODO(hinoka): Use logging.
 
 import cStringIO
 import codecs
 import collections
@@ skipping 55 matching lines @@
                   '..',      # ROOT_DIR
                   'build',
                   'scripts'),
         path.join(SLAVE_DIR, '..', 'build', 'scripts'),
     ], default=path.dirname(THIS_DIR))
 BUILD_DIR = path.dirname(SCRIPTS_DIR)
 ROOT_DIR = path.dirname(BUILD_DIR)
 
 DEPOT_TOOLS_DIR = path.abspath(path.join(THIS_DIR, '..', '..', '..'))
 
+BUILD_INTERNAL_DIR = check_dir(
+    'build_internal', [
+        path.join(ROOT_DIR, 'build_internal'),
+        path.join(ROOT_DIR,      # .recipe_deps
+                  path.pardir,   # slave
+                  path.pardir,   # scripts
+                  path.pardir),  # build_internal
+    ])
+
+
 CHROMIUM_GIT_HOST = 'https://chromium.googlesource.com'
 CHROMIUM_SRC_URL = CHROMIUM_GIT_HOST + '/chromium/src.git'
 
-RECOGNIZED_PATHS = {
-    '/chrome/trunk/src':
-        CHROMIUM_SRC_URL,
-    '/chrome/trunk/src/tools/cros.DEPS':
-        CHROMIUM_GIT_HOST + '/chromium/src/tools/cros.DEPS.git',
-    '/chrome-internal/trunk/src-internal':
-        'https://chrome-internal.googlesource.com/chrome/src-internal.git',
-}
-
 # Official builds use buildspecs, so this is a special case.
 BUILDSPEC_TYPE = collections.namedtuple('buildspec',
     ('container', 'version'))
 BUILDSPEC_RE = (r'^/chrome-internal/trunk/tools/buildspec/'
                  '(build|branches|releases)/(.+)$')
 GIT_BUILDSPEC_PATH = ('https://chrome-internal.googlesource.com/chrome/tools/'
                       'buildspec')
 BRANCH_HEADS_REFSPEC = '+refs/branch-heads/*'
 
 BUILDSPEC_COMMIT_RE = (
@@ skipping 62 matching lines @@
         'src/tools/swarm_client/': 'got_swarm_client_revision',
         'src/tools/swarming_client/': 'got_swarming_client_revision',
         'src/third_party/WebKit/': 'got_webkit_revision',
         'src/third_party/webrtc/': 'got_webrtc_revision',
         'src/v8/': 'got_v8_revision',
     }
 }
 
 
 BOT_UPDATE_MESSAGE = """
-Bot Update Debugging information:
+What is the "Bot Update" step?
+==============================
+
+This step ensures that the source checkout on the bot (e.g. Chromium's src/ and
+its dependencies) is checked out in a consistent state. This means that all of
+the necessary repositories are checked out, no extra repositories are checked
+out, and no locally modified files are present.
+
+These actions used to be taken care of by the "gclient revert" and "update"
+steps. However, those steps are known to be buggy and occasionally flaky. This
+step has two main advantages over them:
+  * it only operates in Git, so the logic can be clearer and cleaner; and
+  * it is a slave-side script, so its behavior can be modified without
+    restarting the master.
+
+Why Git, you ask? Because that is the direction that the Chromium project is
+heading. This step is an integral part of the transition from using the SVN repo
+at chrome/trunk/src to using the Git repo src.git. Please pardon the dust while
+we fully convert everything to Git. This message will get out of your way
+eventually, and the waterfall will be a happier place because of it.
+
+This step can be activated or deactivated independently on every builder on
+every master. When it is active, the "gclient revert" and "update" steps become
+no-ops. When it is inactive, it prints this message, cleans up after itself, and
+lets everything else continue as though nothing has changed. Eventually, when
+everything is stable enough, this step will replace them entirely.
+
+Debugging information:
 (master/builder/slave may be unspecified on recipes)
+master: %(master)s
+builder: %(builder)s
+slave: %(slave)s
+forced by recipes: %(recipe)s
 CURRENT_DIR: %(CURRENT_DIR)s
 BUILDER_DIR: %(BUILDER_DIR)s
 SLAVE_DIR: %(SLAVE_DIR)s
 THIS_DIR: %(THIS_DIR)s
 SCRIPTS_DIR: %(SCRIPTS_DIR)s
 BUILD_DIR: %(BUILD_DIR)s
 ROOT_DIR: %(ROOT_DIR)s
-DEPOT_TOOLS_DIR: %(DEPOT_TOOLS_DIR)s"""
+DEPOT_TOOLS_DIR: %(DEPOT_TOOLS_DIR)s
+bot_update.py is:"""
+
+ACTIVATED_MESSAGE = """ACTIVE.
+The bot will perform a Git checkout in this step.
+The "gclient revert" and "update" steps are no-ops.
+
+"""
+
+NOT_ACTIVATED_MESSAGE = """INACTIVE.
+This step does nothing. You actually want to look at the "update" step.
+
+"""
+
 
 GCLIENT_TEMPLATE = """solutions = %(solutions)s
 
 cache_dir = r%(cache_dir)s
 %(target_os)s
 %(target_os_only)s
 """
 
 
+internal_data = {}
+if BUILD_INTERNAL_DIR:
+  local_vars = {}
+  try:
+    execfile(os.path.join(
+        BUILD_INTERNAL_DIR, 'scripts', 'slave', 'bot_update_cfg.py'),
+        local_vars)
+  except Exception:
+    # Same as if BUILD_INTERNAL_DIR didn't exist in the first place.
+    print 'Warning: unable to read internal configuration file.'
+    print 'If this is an internal bot, this step may be erroneously inactive.'
+  internal_data = local_vars
+
+RECOGNIZED_PATHS = {
+    # If SVN path matches key, the entire URL is rewritten to the Git url.
+    '/chrome/trunk/src':
+        CHROMIUM_SRC_URL,
+    '/chrome/trunk/src/tools/cros.DEPS':
+        CHROMIUM_GIT_HOST + '/chromium/src/tools/cros.DEPS.git',
+}
+RECOGNIZED_PATHS.update(internal_data.get('RECOGNIZED_PATHS', {}))
+
+ENABLED_MASTERS = [
+    'bot_update.always_on',
+    'chromium.android',
+    'chromium.angle',
+    'chromium.chrome',
+    'chromium.chromedriver',
+    'chromium.chromiumos',
+    'chromium',
+    'chromium.fyi',
+    'chromium.goma',
+    'chromium.gpu',
+    'chromium.gpu.fyi',
+    'chromium.infra',
+    'chromium.infra.cron',
+    'chromium.linux',
+    'chromium.lkgr',
+    'chromium.mac',
+    'chromium.memory',
+    'chromium.memory.fyi',
+    'chromium.perf',
+    'chromium.perf.fyi',
+    'chromium.swarm',
+    'chromium.webkit',
+    'chromium.webrtc',
+    'chromium.webrtc.fyi',
+    'chromium.win',
+    'client.catapult',
+    'client.drmemory',
+    'client.mojo',
+    'client.nacl',
+    'client.nacl.ports',
+    'client.nacl.sdk',
+    'client.nacl.toolchain',
+    'client.pdfium',
+    'client.skia',
+    'client.skia.fyi',
+    'client.v8',
+    'client.v8.branches',
+    'client.v8.fyi',
+    'client.webrtc',
+    'client.webrtc.fyi',
+    'tryserver.blink',
+    'tryserver.client.catapult',
+    'tryserver.client.mojo',
+    'tryserver.chromium.android',
+    'tryserver.chromium.angle',
+    'tryserver.chromium.linux',
+    'tryserver.chromium.mac',
+    'tryserver.chromium.perf',
+    'tryserver.chromium.win',
+    'tryserver.infra',
+    'tryserver.nacl',
+    'tryserver.v8',
+    'tryserver.webrtc',
+]
+ENABLED_MASTERS += internal_data.get('ENABLED_MASTERS', [])
+
+ENABLED_BUILDERS = {
+    'client.dart.fyi': [
+        'v8-linux-release',
+        'v8-mac-release',
+        'v8-win-release',
+    ],
+    'client.dynamorio': [
+        'linux-v8-dr',
+    ],
+}
+ENABLED_BUILDERS.update(internal_data.get('ENABLED_BUILDERS', {}))
+
+ENABLED_SLAVES = {}
+ENABLED_SLAVES.update(internal_data.get('ENABLED_SLAVES', {}))
+
+# Disabled filters get run AFTER enabled filters, so for example if a builder
+# config is enabled, but a bot on that builder is disabled, that bot will
+# be disabled.
+DISABLED_BUILDERS = {}
+DISABLED_BUILDERS.update(internal_data.get('DISABLED_BUILDERS', {}))
+
+DISABLED_SLAVES = {}
+DISABLED_SLAVES.update(internal_data.get('DISABLED_SLAVES', {}))
+
+# These masters work only in Git, meaning for got_revision, always output
+# a git hash rather than a SVN rev.
+GIT_MASTERS = [
+    'client.v8',
+    'client.v8.branches',
+    'tryserver.v8',
+]
+GIT_MASTERS += internal_data.get('GIT_MASTERS', [])
+
+
 # How many times to try before giving up.
 ATTEMPTS = 5
 
+# Find deps2git
+DEPS2GIT_DIR_PATH = path.join(SCRIPTS_DIR, 'tools', 'deps2git')
+DEPS2GIT_PATH = path.join(DEPS2GIT_DIR_PATH, 'deps2git.py')
+S2G_INTERNAL_PATH = path.join(SCRIPTS_DIR, 'tools', 'deps2git_internal',
+                              'svn_to_git_internal.py')
 GIT_CACHE_PATH = path.join(DEPOT_TOOLS_DIR, 'git_cache.py')
 
 # Find the patch tool.
 if sys.platform.startswith('win'):
-  PATCH_TOOL = path.join(THIS_DIR, 'patch.EXE')
+  if not BUILD_INTERNAL_DIR:
+    print 'Warning: could not find patch tool because there is no '
+    print 'build_internal present.'
+    PATCH_TOOL = None
+  else:
+    PATCH_TOOL = path.join(BUILD_INTERNAL_DIR, 'tools', 'patch.EXE')
 else:
   PATCH_TOOL = '/usr/bin/patch'
 
 # If there is less than 100GB of disk space on the system, then we do
 # a shallow checkout.
 SHALLOW_CLONE_THRESHOLD = 100 * 1024 * 1024 * 1024
 
 
 class SubprocessFailed(Exception):
   def __init__(self, message, code, output):
@@ skipping 11 matching lines @@
 
 
 class SVNRevisionNotFound(Exception):
   pass
 
 
 class InvalidDiff(Exception):
   pass
 
 
+class Inactive(Exception):
+  """Not really an exception, just used to exit early cleanly."""
+  pass
+
+
 RETRY = object()
 OK = object()
 FAIL = object()
 
 
 class PsPrinter(object):
   def __init__(self, interval=300):
     self.interval = interval
     self.active = sys.platform.startswith('linux2')
     self.thread = None
@@ skipping 108 matching lines @@
 
 def get_gclient_spec(solutions, target_os, target_os_only, git_cache_dir):
   return GCLIENT_TEMPLATE % {
       'solutions': pprint.pformat(solutions, indent=4),
       'cache_dir': '"%s"' % git_cache_dir,
       'target_os': ('\ntarget_os=%s' % target_os) if target_os else '',
       'target_os_only': '\ntarget_os_only=%s' % target_os_only
   }
 
 
+def check_enabled(master, builder, slave):
+  if master in ENABLED_MASTERS:
+    return True
+  builder_list = ENABLED_BUILDERS.get(master)
+  if builder_list and builder in builder_list:
+    return True
+  slave_list = ENABLED_SLAVES.get(master)
+  if slave_list and slave in slave_list:
+    return True
+  return False
+
+
+def check_disabled(master, builder, slave):
+  """Returns True if disabled, False if not disabled."""
+  builder_list = DISABLED_BUILDERS.get(master)
+  if builder_list and builder in builder_list:
+    return True
+  slave_list = DISABLED_SLAVES.get(master)
+  if slave_list and slave in slave_list:
+    return True
+  return False
+
+
+def check_valid_host(master, builder, slave):
+  return (check_enabled(master, builder, slave)
+          and not check_disabled(master, builder, slave))
+
+
 def maybe_ignore_revision(revision, buildspec):
   """Handle builders that don't care what buildbot tells them to build.
 
   This is especially the case with branch builders that build from buildspecs
   and/or trigger off multiple repositories, where the --revision passed in has
   nothing to do with the solution being built. Clearing the revision in this
   case causes bot_update to use HEAD rather that trying to checkout an
   inappropriate version of the solution.
   """
   if buildspec and buildspec.container == 'branches':
@@ skipping 207 matching lines @@
     footers[m.group(1)] = m.group(2).strip()
   return footers
 
 
 def get_commit_message_footer(message, key):
   """Returns: (str/None) The footer value for 'key', or None if none was found.
   """
   return get_commit_message_footer_map(message).get(key)
 
 
+def get_svn_rev(git_hash, dir_name):
+  log = git('log', '-1', git_hash, cwd=dir_name)
+  git_svn_id = get_commit_message_footer(log, GIT_SVN_ID_FOOTER_KEY)
+  if not git_svn_id:
+    return None
+  m = GIT_SVN_ID_RE.match(git_svn_id)
+  if not m:
+    return None
+  return int(m.group(2))
+
+
 def get_git_hash(revision, branch, sln_dir):
   """We want to search for the SVN revision on the git-svn branch.
 
   Note that git will search backwards from origin/master.
   """
   match = "^%s: [^ ]*@%s " % (GIT_SVN_ID_FOOTER_KEY, revision)
   ref = branch if branch.startswith('refs/') else 'origin/%s' % branch
   cmd = ['log', '-E', '--grep', match, '--format=%H', '--max-count=1', ref]
   result = git(*cmd, cwd=sln_dir).strip()
   if result:
     return result
   raise SVNRevisionNotFound('We can\'t resolve svn r%s into a git hash in %s' %
                             (revision, sln_dir))
 
 
+def _last_commit_for_file(filename, repo_base):
+  cmd = ['log', '--format=%H', '--max-count=1', '--', filename]
+  return git(*cmd, cwd=repo_base).strip()
+
+
+def need_to_run_deps2git(repo_base, deps_file, deps_git_file):
+  """Checks to see if we need to run deps2git.
+
+  Returns True if there was a DEPS change after the last .DEPS.git update
+  or if DEPS has local modifications.
+  """
+  # See if DEPS is dirty
+  deps_file_status = git(
+      'status', '--porcelain', deps_file, cwd=repo_base).strip()
+  if deps_file_status and deps_file_status.startswith('M '):
+    return True
+
+  last_known_deps_ref = _last_commit_for_file(deps_file, repo_base)
+  last_known_deps_git_ref = _last_commit_for_file(deps_git_file, repo_base)
+  merge_base_ref = git('merge-base', last_known_deps_ref,
+                       last_known_deps_git_ref, cwd=repo_base).strip()
+
+  # If the merge base of the last DEPS and last .DEPS.git file is not
+  # equivilent to the hash of the last DEPS file, that means the DEPS file
+  # was committed after the last .DEPS.git file.
+  return last_known_deps_ref != merge_base_ref
+
+
+def ensure_deps2git(solution, shallow, git_cache_dir):
+  repo_base = path.join(os.getcwd(), solution['name'])
+  deps_file = path.join(repo_base, 'DEPS')
+  deps_git_file = path.join(repo_base, '.DEPS.git')
+  if (not git('ls-files', 'DEPS', cwd=repo_base).strip() or
+      not git('ls-files', '.DEPS.git', cwd=repo_base).strip()):
+    return
+
+  print 'Checking if %s is newer than %s' % (deps_file, deps_git_file)
+  if not need_to_run_deps2git(repo_base, deps_file, deps_git_file):
+    return
+
+  print '===DEPS file modified, need to run deps2git==='
+  cmd = [sys.executable, DEPS2GIT_PATH,
+         '--workspace', os.getcwd(),
+         '--cache_dir', git_cache_dir,
+         '--deps', deps_file,
+         '--out', deps_git_file]
+  if 'chrome-internal.googlesource' in solution['url']:
+    cmd.extend(['--extra-rules', S2G_INTERNAL_PATH])
+  if shallow:
+    cmd.append('--shallow')
+  call(*cmd)
+
+
 def emit_log_lines(name, lines):
   for line in lines.splitlines():
     print '@@@STEP_LOG_LINE@%s@%s@@@' % (name, line)
   print '@@@STEP_LOG_END@%s@@@' % name
 
 
 def emit_properties(properties):
   for property_name, property_value in sorted(properties.items()):
     print '@@@SET_BUILD_PROPERTY@%s@"%s"@@@' % (property_name, property_value)
 
@@ skipping 45 matching lines @@
       # rev_num is really a svn revision number, convert it into a git hash.
       git_ref = get_git_hash(int(revision), branch, folder_name)
     else:
       # rev_num is actually a git hash or ref, we can just use it.
       git_ref = revision
     git('checkout', '--force', git_ref, cwd=folder_name)
   else:
     ref = branch if branch.startswith('refs/') else 'origin/%s' % branch
     git('checkout', '--force', ref, cwd=folder_name)
 
-
 def git_checkout(solutions, revisions, shallow, refs, git_cache_dir):
   build_dir = os.getcwd()
   # Before we do anything, break all git_cache locks.
   if path.isdir(git_cache_dir):
     git('cache', 'unlock', '-vv', '--force', '--all',
         '--cache-dir', git_cache_dir)
     for item in os.listdir(git_cache_dir):
       filename = os.path.join(git_cache_dir, item)
       if item.endswith('.lock'):
         raise Exception('%s exists after cache unlock' % filename)
@@ skipping 40 matching lines @@
         # Exited abnormally, theres probably something wrong.
         # Lets wipe the checkout and try again.
         tries_left -= 1
         if tries_left > 0:
           print 'Something failed: %s.' % str(e)
           print 'waiting 5 seconds and trying again...'
           time.sleep(5)
         else:
           raise
         remove(sln_dir)
+      except SVNRevisionNotFound:
+        tries_left -= 1
+        if tries_left > 0:
+          # If we don't have the correct revision, wait and try again.
+          print 'We can\'t find revision %s.' % revision
+          print 'The svn to git replicator is probably falling behind.'
+          print 'waiting 5 seconds and trying again...'
+          time.sleep(5)
+        else:
+          raise
 
     git('clean', '-dff', cwd=sln_dir)
 
     if first_solution:
       git_ref = git('log', '--format=%H', '--max-count=1',
                     cwd=sln_dir).strip()
     first_solution = False
   return git_ref
 
 
+def _download(url):
+  """Fetch url and return content, with retries for flake."""
+  for attempt in xrange(ATTEMPTS):
+    try:
+      return urllib2.urlopen(url).read()
+    except Exception:
+      if attempt == ATTEMPTS - 1:
+        raise
+
+
 def parse_diff(diff):
   """Takes a unified diff and returns a list of diffed files and their diffs.
 
   The return format is a list of pairs of:
     (<filename>, <diff contents>)
   <diff contents> is inclusive of the diff line.
   """
   result = []
   current_diff = ''
   current_header = None
@@ skipping 189 matching lines @@
   # Compose a commit position from 'git-svn' metadata
   value = footer_map.get(GIT_SVN_ID_FOOTER_KEY)
   if value:
     m = GIT_SVN_ID_RE.match(value)
     if not m:
       raise ValueError("Invalid 'git-svn' value: [%s]" % (value,))
     return get_commit_position_for_git_svn(m.group(1), m.group(2))
   return None
 
 
-def parse_got_revision(gclient_output, got_revision_mapping):
-  """Translate git gclient revision mapping to build properties."""
+def parse_got_revision(gclient_output, got_revision_mapping, use_svn_revs):
+  """Translate git gclient revision mapping to build properties.
+
+  If use_svn_revs is True, then translate git hashes in the revision mapping
+  to svn revision numbers.
+  """
   properties = {}
   solutions_output = {
       # Make sure path always ends with a single slash.
       '%s/' % path.rstrip('/') : solution_output for path, solution_output
       in gclient_output['solutions'].iteritems()
   }
   for dir_name, property_name in got_revision_mapping.iteritems():
     # Make sure dir_name always ends with a single slash.
     dir_name = '%s/' % dir_name.rstrip('/')
     if dir_name not in solutions_output:
       continue
     solution_output = solutions_output[dir_name]
     if solution_output.get('scm') is None:
       # This is an ignored DEPS, so the output got_revision should be 'None'.
       git_revision = revision = commit_position = None
     else:
       # Since we are using .DEPS.git, everything had better be git.
       assert solution_output.get('scm') == 'git'
       git_revision = git('rev-parse', 'HEAD', cwd=dir_name).strip()
-      revision = git_revision
+      if use_svn_revs:
+        revision = get_svn_rev(git_revision, dir_name)
+        if not revision:
+          revision = git_revision
+      else:
+        revision = git_revision
       commit_position = get_commit_position(dir_name)
 
     properties[property_name] = revision
     if revision != git_revision:
       properties['%s_git' % property_name] = git_revision
     if commit_position:
       properties['%s_cp' % property_name] = commit_position
 
   return properties
 
@@ skipping 11 matching lines @@
 def ensure_deps_revisions(deps_url_mapping, solutions, revisions):
   """Ensure correct DEPS revisions, ignores solutions."""
   for deps_name, deps_data in sorted(deps_url_mapping.items()):
     if deps_name.strip('/') in solutions:
       # This has already been forced to the correct solution by git_checkout().
       continue
     revision = get_target_revision(deps_name, deps_data.get('url', None),
                                    revisions)
     if not revision:
       continue
+    # TODO(hinoka): Catch SVNRevisionNotFound error maybe?
     git('fetch', 'origin', cwd=deps_name)
     force_revision(deps_name, revision)
 
 
 def ensure_checkout(solutions, revisions, first_sln, target_os, target_os_only,
                     patch_root, issue, patchset, patch_url, rietveld_server,
                     gerrit_repo, gerrit_ref, revision_mapping,
                     apply_issue_email_file, apply_issue_key_file, buildspec,
                     gyp_env, shallow, runhooks, refs, git_cache_dir):
   # Get a checkout of each solution, without DEPS or hooks.
@@ skipping 16 matching lines @@
       target = '/'.join([relative_root, 'DEPS']).lstrip('/')
       if patches:
         apply_svn_patch(patch_root, patches, whitelist=[target])
         already_patched.append(target)
       elif issue:
         apply_rietveld_issue(issue, patchset, patch_root, rietveld_server,
                              revision_mapping, git_ref, apply_issue_email_file,
                              apply_issue_key_file, whitelist=[target])
         already_patched.append(target)
 
+  if not buildspec:
+    # Run deps2git if there is a DEPS change after the last .DEPS.git commit.
+    for solution in solutions:
+      ensure_deps2git(solution, shallow, git_cache_dir)
+
   # Ensure our build/ directory is set up with the correct .gclient file.
   gclient_configure(solutions, target_os, target_os_only, git_cache_dir)
 
   # Let gclient do the DEPS syncing.
   # The branch-head refspec is a special case because its possible Chrome
   # src, which contains the branch-head refspecs, is DEPSed in.
   gclient_output = gclient_sync(buildspec or BRANCH_HEADS_REFSPEC in refs,
                                 shallow)
 
   # Now that gclient_sync has finished, we should revert any .DEPS.git so that
@@ skipping 83 matching lines @@
 
   parse.add_option('--issue', help='Issue number to patch from.')
   parse.add_option('--patchset',
                    help='Patchset from issue to patch from, if applicable.')
   parse.add_option('--apply_issue_email_file',
                    help='--email-file option passthrough for apply_patch.py.')
   parse.add_option('--apply_issue_key_file',
                    help='--private-key-file option passthrough for '
                         'apply_patch.py.')
   parse.add_option('--patch_url', help='Optional URL to SVN patch.')
+  parse.add_option('--root', dest='patch_root',
+                   help='DEPRECATED: Use --patch_root.')
   parse.add_option('--patch_root', help='Directory to patch on top of.')
   parse.add_option('--rietveld_server',
                    default='codereview.chromium.org',
                    help='Rietveld server.')
   parse.add_option('--gerrit_repo',
                    help='Gerrit repository to pull the ref from.')
   parse.add_option('--gerrit_ref', help='Gerrit ref to apply.')
   parse.add_option('--specs', help='Gcilent spec.')
+  parse.add_option('--master', help='Master name.')
+  parse.add_option('-f', '--force', action='store_true',
+                   help='Bypass check to see if we want to be run. '
+                        'Should ONLY be used locally or by smart recipes.')
   parse.add_option('--revision_mapping',
                    help='{"path/to/repo/": "property_name"}')
   parse.add_option('--revision_mapping_file',
                    help=('Same as revision_mapping, except its a path to a json'
                          ' file containing that format.'))
   parse.add_option('--revision', action='append', default=[],
                    help='Revision to check out. Can be an SVN revision number, '
                         'git hash, or any form of git ref.  Can prepend '
                         'root@<rev> to specify which repository, where root '
                         'is either a filesystem path, git https url, or '
                         'svn url. To specify Tip of Tree, set rev to HEAD.'
                         'To specify a git branch and an SVN rev, <rev> can be '
                         'set to <branch>:<revision>.')
   parse.add_option('--output_manifest', action='store_true',
                    help=('Add manifest json to the json output.'))
+  parse.add_option('--slave_name', default=socket.getfqdn().split('.')[0],
+                   help='Hostname of the current machine, '
+                   'used for determining whether or not to activate.')
+  parse.add_option('--builder_name', help='Name of the builder, '
+                   'used for determining whether or not to activate.')
   parse.add_option('--build_dir', default=os.getcwd())
   parse.add_option('--flag_file', default=path.join(os.getcwd(),
                                                     'update.flag'))
   parse.add_option('--shallow', action='store_true',
                    help='Use shallow clones for cache repositories.')
   parse.add_option('--gyp_env', action='append', default=[],
                    help='Environment variables to pass into gclient runhooks.')
   parse.add_option('--clobber', action='store_true',
                    help='Delete checkout first, always')
   parse.add_option('--bot_update_clobber', action='store_true', dest='clobber',
@@ skipping 41 matching lines @@
 
   # Because we print CACHE_DIR out into a .gclient file, and then later run
   # eval() on it, backslashes need to be escaped, otherwise "E:\b\build" gets
   # parsed as "E:[\x08][\x08]uild".
   if sys.platform.startswith('win'):
     options.git_cache_dir = options.git_cache_dir.replace('\\', '\\\\')
 
   return options, args
 
 
-def prepare(options, git_slns):
+def prepare(options, git_slns, active):
   """Prepares the target folder before we checkout."""
   dir_names = [sln.get('name') for sln in git_slns if 'name' in sln]
+  # If we're active now, but the flag file doesn't exist (we weren't active
+  # last run) or vice versa, blow away all checkouts.
+  if bool(active) != bool(check_flag(options.flag_file)):
+    ensure_no_checkout(dir_names, '*')
   if options.output_json:
     # Make sure we tell recipes that we didn't run if the script exits here.
-    emit_json(options.output_json, did_run=True)
-  if options.clobber:
-    ensure_no_checkout(dir_names, '*')
+    emit_json(options.output_json, did_run=active)
+  if active:
+    if options.clobber:
+      ensure_no_checkout(dir_names, '*')
+    else:
+      ensure_no_checkout(dir_names, '.svn')
+    emit_flag(options.flag_file)
   else:
-    ensure_no_checkout(dir_names, '.svn')
-  emit_flag(options.flag_file)
+    delete_flag(options.flag_file)
+    raise Inactive  # This is caught in main() and we exit cleanly.
 
   # Do a shallow checkout if the disk is less than 100GB.
   total_disk_space, free_disk_space = get_total_disk_space()
   total_disk_space_gb = int(total_disk_space / (1024 * 1024 * 1024))
   used_disk_space_gb = int((total_disk_space - free_disk_space)
                            / (1024 * 1024 * 1024))
   percent_used = int(used_disk_space_gb * 100 / total_disk_space_gb)
   step_text = '[%dGB/%dGB used (%d%%)]' % (used_disk_space_gb,
                                            total_disk_space_gb,
                                            percent_used)
   if not options.output_json:
     print '@@@STEP_TEXT@%s@@@' % step_text
   if not options.shallow:
     options.shallow = (total_disk_space < SHALLOW_CLONE_THRESHOLD
                        and not options.no_shallow)
 
   # The first solution is where the primary DEPS file resides.
   first_sln = dir_names[0]
 
   # Split all the revision specifications into a nice dict.
   print 'Revisions: %s' % options.revision
   revisions = parse_revisions(options.revision, first_sln)
   print 'Fetching Git checkout at %s@%s' % (first_sln, revisions[first_sln])
   return revisions, step_text
 
 
-def checkout(options, git_slns, specs, buildspec,
+def checkout(options, git_slns, specs, buildspec, master,
              svn_root, revisions, step_text):
   first_sln = git_slns[0]['name']
   dir_names = [sln.get('name') for sln in git_slns if 'name' in sln]
   try:
     # Outer try is for catching patch failures and exiting gracefully.
     # Inner try is for catching gclient failures and retrying gracefully.
     try:
       checkout_parameters = dict(
           # First, pass in the base of what we want to check out.
           solutions=git_slns,
@@ skipping 41 matching lines @@
                 patch_root=options.patch_root,
                 patch_failure=True,
                 step_text='%s PATCH FAILED' % step_text,
                 fixed_revisions=revisions)
     else:
       # If we're not on recipes, tell annotator about our got_revisions.
       emit_log_lines('patch error', e.output)
       print '@@@STEP_TEXT@%s PATCH FAILED@@@' % step_text
     raise
 
+  # Revision is an svn revision, unless it's a git master.
+  use_svn_rev = master not in GIT_MASTERS
+
   # Take care of got_revisions outputs.
   revision_mapping = dict(GOT_REVISION_MAPPINGS.get(svn_root, {}))
   if options.revision_mapping:
     revision_mapping.update(options.revision_mapping)
 
   # If the repo is not in the default GOT_REVISION_MAPPINGS and no
   # revision_mapping were specified on the command line then
   # default to setting 'got_revision' based on the first solution.
   if not revision_mapping:
     revision_mapping[first_sln] = 'got_revision'
 
-  got_revisions = parse_got_revision(gclient_output, revision_mapping)
+  got_revisions = parse_got_revision(gclient_output, revision_mapping,
+                                     use_svn_rev)
 
   if not got_revisions:
     # TODO(hinoka): We should probably bail out here, but in the interest
     # of giving mis-configured bots some time to get fixed use a dummy
     # revision here.
     got_revisions = { 'got_revision': 'BOT_UPDATE_NO_REV_FOUND' }
     #raise Exception('No got_revision(s) found in gclient output')
 
   if options.output_json:
     manifest = create_manifest() if options.output_manifest else None
     # Tell recipes information such as root, got_revision, etc.
     emit_json(options.output_json,
               did_run=True,
               root=first_sln,
               patch_root=options.patch_root,
               step_text=step_text,
               fixed_revisions=revisions,
               properties=got_revisions,
               manifest=manifest)
   else:
     # If we're not on recipes, tell annotator about our got_revisions.
     emit_properties(got_revisions)
 
 
-def print_help_text(master, builder, slave):
+def print_help_text(force, output_json, active, master, builder, slave):
   """Print helpful messages to tell devs whats going on."""
+  if force and output_json:
+    recipe_force = 'Forced on by recipes'
+  elif active and output_json:
+    recipe_force = 'Off by recipes, but forced on by bot update'
+  elif not active and output_json:
+    recipe_force = 'Forced off by recipes'
+  else:
+    recipe_force = 'N/A. Was not called by recipes'
+
   print BOT_UPDATE_MESSAGE % {
+    'master': master or 'Not specified',
+    'builder': builder or 'Not specified',
+    'slave': slave or 'Not specified',
+    'recipe': recipe_force,
     'CURRENT_DIR': CURRENT_DIR,
     'BUILDER_DIR': BUILDER_DIR,
     'SLAVE_DIR': SLAVE_DIR,
     'THIS_DIR': THIS_DIR,
     'SCRIPTS_DIR': SCRIPTS_DIR,
     'BUILD_DIR': BUILD_DIR,
     'ROOT_DIR': ROOT_DIR,
     'DEPOT_TOOLS_DIR': DEPOT_TOOLS_DIR,
   },
+  print ACTIVATED_MESSAGE if active else NOT_ACTIVATED_MESSAGE
 
 
 def main():
   # Get inputs.
   options, _ = parse_args()
   builder = options.builder_name
   slave = options.slave_name
   master = options.master
 
-  # Prints some debugging information.
-  print_help_text(master, builder, slave)
+  # Check if this script should activate or not.
+  active = check_valid_host(master, builder, slave) or options.force or False
+
+  # Print a helpful message to tell developers whats going on with this step.
+  print_help_text(
+      options.force, options.output_json, active, master, builder, slave)
 
   # Parse, munipulate, and print the gclient solutions.
   specs = {}
   exec(options.specs, specs)
   svn_solutions = specs.get('solutions', [])
   git_slns, svn_root, buildspec = solutions_to_git(svn_solutions)
   options.revision = maybe_ignore_revision(options.revision, buildspec)
 
   solutions_printer(git_slns)
 
   try:
     # Dun dun dun, the main part of bot_update.
-    revisions, step_text = prepare(options, git_slns)
-    checkout(options, git_slns, specs, buildspec, svn_root, revisions,
+    revisions, step_text = prepare(options, git_slns, active)
+    checkout(options, git_slns, specs, buildspec, master, svn_root, revisions,
              step_text)
 
+  except Inactive:
+    # Not active, should count as passing.
+    pass
   except PatchFailed as e:
     emit_flag(options.flag_file)
     # Return a specific non-zero exit code for patch failure (because it is
     # a failure), but make it different than other failures to distinguish
     # between infra failures (independent from patch author), and patch
     # failures (that patch author can fix). However, PatchFailure due to
     # download patch failure is still an infra problem.
     if e.code == 3:
       # Patch download problem.
       return 87
     # Genuine patch problem.
     return 88
   except Exception:
     # Unexpected failure.
     emit_flag(options.flag_file)
     raise
   else:
     emit_flag(options.flag_file)
 
 
 if __name__ == '__main__':
   sys.exit(main())