Show additional warning about managed workflow.

tools/check_git_config.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.
 
 """Script that attempts to push to a special git repository to verify that git
 credentials are configured correctly. It also verifies that gclient solution is
 configured to use git checkout.
 
 It will be added as gclient hook shortly before Chromium switches to git and
@@ skipping 26 matching lines @@
 
 
 # Absolute path to src/ directory.
 REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 # Absolute path to a file with gclient solutions.
 GCLIENT_CONFIG = os.path.join(os.path.dirname(REPO_ROOT), '.gclient')
 
 # Incremented whenever some changes to scrip logic are made. Change in version
 # will cause the check to be rerun on next gclient runhooks invocation.
-CHECKER_VERSION = 0
+CHECKER_VERSION = 1
 
 # Do not attempt to upload a report after this date.
 UPLOAD_DISABLE_TS = datetime.datetime(2014, 10, 1)
 
 # URL to POST json with results to.
 MOTHERSHIP_URL = (
     'https://chromium-git-access.appspot.com/'
     'git_access/api/v1/reports/access_check')
 
 # Repository to push test commits to.
 TEST_REPO_URL = 'https://chromium.googlesource.com/a/playground/access_test'
 
 # Git-compatible gclient solution.
 GOOD_GCLIENT_SOLUTION = {
   'name': 'src',
   'deps_file': '.DEPS.git',
   'managed': False,
   'url': 'https://chromium.googlesource.com/chromium/src.git',
 }
 
 # Possible chunks of git push response in case .netrc is misconfigured.
 BAD_ACL_ERRORS = (
   '(prohibited by Gerrit)',
   'does not match your user account',
+  'Git repository not found',
   'Invalid user name or password',
   'Please make sure you have the correct access rights',
 )
 
+# Git executable to call.
+GIT_EXE = 'git.bat' if sys.platform == 'win32' else 'git'
+
 
 def is_on_bot():
   """True when running under buildbot."""
   return os.environ.get('CHROME_HEADLESS') == '1'
 
 
 def is_in_google_corp():
   """True when running in google corp network."""
   try:
     return socket.getfqdn().endswith('.corp.google.com')
@@ skipping 12 matching lines @@
   return os.path.exists(os.path.join(REPO_ROOT, '.svn'))
 
 
 def read_git_config(prop):
   """Reads git config property of src.git repo.
 
   Returns empty string in case of errors.
   """
   try:
     proc = subprocess.Popen(
-        ['git', 'config', prop], stdout=subprocess.PIPE, cwd=REPO_ROOT)
+        [GIT_EXE, 'config', prop], stdout=subprocess.PIPE, cwd=REPO_ROOT)
     out, _ = proc.communicate()
     return out.strip()
   except OSError as exc:
     if exc.errno != errno.ENOENT:
       logging.exception('Unexpected error when calling git')
     return ''
 
 
 def read_netrc_user(netrc_obj, host):
   """Reads 'user' field of a host entry in netrc.
 
   Returns empty string if netrc is missing, or host is not there.
   """
   if not netrc_obj:
     return ''
   entry = netrc_obj.authenticators(host)
   if not entry:
     return ''
   return entry[0]
 
 
 def get_git_version():
   """Returns version of git or None if git is not available."""
   try:
-    proc = subprocess.Popen(['git', '--version'], stdout=subprocess.PIPE)
+    proc = subprocess.Popen([GIT_EXE, '--version'], stdout=subprocess.PIPE)
     out, _ = proc.communicate()
     return out.strip() if proc.returncode == 0 else ''
   except OSError as exc:
     if exc.errno != errno.ENOENT:
       logging.exception('Unexpected error when calling git')
     return ''
 
 
 def read_gclient_solution():
   """Read information about 'src' gclient solution from .gclient file.
 
   Returns tuple:
     (url, deps_file, managed)
     or
     (None, None, None) if no such solution.
   """
   try:
     env = {}
     execfile(GCLIENT_CONFIG, env, env)
     for sol in env['solutions']:
       if sol['name'] == 'src':
         return sol.get('url'), sol.get('deps_file'), sol.get('managed')
     return None, None, None
   except Exception:
     logging.exception('Failed to read .gclient solution')
     return None, None, None
 
 
+def read_git_insteadof(host):
+  """Reads relevant insteadOf config entries."""
+  try:
+    proc = subprocess.Popen([GIT_EXE, 'config', '-l'], stdout=subprocess.PIPE)
+    out, _ = proc.communicate()
+    lines = []
+    for line in out.strip().split('\n'):
+      line = line.lower()
+      if 'insteadof=' in line and host in line:
+        lines.append(line)
+    return '\n'.join(lines)
+  except OSError as exc:
+    if exc.errno != errno.ENOENT:
+      logging.exception('Unexpected error when calling git')
+    return ''
+
+
 def scan_configuration():
   """Scans local environment for git related configuration values."""
   # Git checkout?
   is_git = is_using_git()
 
   # On Windows HOME should be set.
   if 'HOME' in os.environ:
     netrc_path = os.path.join(
         os.environ['HOME'],
         '_netrc' if sys.platform.startswith('win') else '.netrc')
@@ skipping 19 matching lines @@
     'checker_version': CHECKER_VERSION,
     'is_git': is_git,
     'is_home_set': 'HOME' in os.environ,
     'is_using_netrc': is_using_netrc,
     'netrc_file_mode': os.stat(netrc_path).st_mode if is_using_netrc else 0,
     'git_version': get_git_version(),
     'platform': sys.platform,
     'username': getpass.getuser(),
     'git_user_email': read_git_config('user.email') if is_git else '',
     'git_user_name': read_git_config('user.name') if is_git else '',
+    'git_insteadof': read_git_insteadof('chromium.googlesource.com'),
     'chromium_netrc_email':
         read_netrc_user(netrc_obj, 'chromium.googlesource.com'),
     'chrome_internal_netrc_email':
         read_netrc_user(netrc_obj, 'chrome-internal.googlesource.com'),
     'gclient_deps': gclient_deps,
     'gclient_managed': gclient_managed,
     'gclient_url': gclient_url,
   }
 
 
@@ skipping 92 matching lines @@
   ref = 'refs/push-test/%s' % conf['chromium_netrc_email']
 
   push_works = False
   flake = False
   started = time.time()
   try:
     logging.warning('Checking push access to the git repository...')
     with temp_directory() as tmp:
       # Prepare a simple commit on a new timeline.
       runner = Runner(tmp, verbose)
-      runner.run(['git', 'init', '.'])
+      runner.run([GIT_EXE, 'init', '.'])
       if conf['git_user_name']:
-        runner.run(['git', 'config', 'user.name', conf['git_user_name']])
+        runner.run([GIT_EXE, 'config', 'user.name', conf['git_user_name']])
       if conf['git_user_email']:
-        runner.run(['git', 'config', 'user.email', conf['git_user_email']])
+        runner.run([GIT_EXE, 'config', 'user.email', conf['git_user_email']])
       with open(os.path.join(tmp, 'timestamp'), 'w') as f:
         f.write(str(int(time.time() * 1000)))
-      runner.run(['git', 'add', 'timestamp'])
-      runner.run(['git', 'commit', '-m', 'Push test.'])
+      runner.run([GIT_EXE, 'add', 'timestamp'])
+      runner.run([GIT_EXE, 'commit', '-m', 'Push test.'])
       # Try to push multiple times if it fails due to issues other than ACLs.
       attempt = 0
       while attempt < 5:
         attempt += 1
         logging.info('Pushing to %s %s', TEST_REPO_URL, ref)
-        ret = runner.run(['git', 'push', TEST_REPO_URL, 'HEAD:%s' % ref, '-f'])
+        ret = runner.run(
+            [GIT_EXE, 'push', TEST_REPO_URL, 'HEAD:%s' % ref, '-f'])
         if not ret:
           push_works = True
           break
         if any(x in runner.log[-1] for x in BAD_ACL_ERRORS):
           push_works = False
           break
   except Exception:
     logging.exception('Unexpected exception when pushing')
     flake = True
 
@@ skipping 11 matching lines @@
       push_log='\n'.join(runner.log),
       push_duration_ms=int((time.time() - started) * 1000))
   return uploaded and not flake
 
 
 def check_gclient_config(conf):
   """Shows warning if gclient solution is not properly configured for git."""
   current = {
     'name': 'src',
     'deps_file': conf['gclient_deps'],
-    'managed': conf['gclient_managed'],
+    'managed': conf['gclient_managed'] or False,
     'url': conf['gclient_url'],
   }
-  if current != GOOD_GCLIENT_SOLUTION:
+  good = GOOD_GCLIENT_SOLUTION
+  if current == good:
+    return
+  # Show big warning if url or deps_file is wrong.
+  if current['url'] != good['url'] or current['deps_file'] != good['deps_file']:
     print '-' * 80
     print 'Your gclient solution is not set to use supported git workflow!'
     print
     print 'Your \'src\' solution (in %s):' % GCLIENT_CONFIG
     print pprint.pformat(current, indent=2)
     print
     print 'Correct \'src\' solution to use git:'
-    print pprint.pformat(GOOD_GCLIENT_SOLUTION, indent=2)
+    print pprint.pformat(good, indent=2)
     print
     print 'Please update your .gclient file ASAP.'
     print '-' * 80
+  # Show smaller (additional) warning about managed workflow.
+  if current['managed']:
+    print '-' * 80
+    print (
+        'You are using managed gclient mode with git, which was deprecated '
+        'on 8/22/13:')
+    print (
+        'https://groups.google.com/a/chromium.org/'
+        'forum/#!topic/chromium-dev/n9N5N3JL2_U')
+    print
+    print (
+        'It is strongly advised to switch to unmanaged mode. For more '
+        'information about managed mode and reasons for its deprecation see:')
+    print 'http://www.chromium.org/developers/how-tos/get-the-code#Managed_mode'
+    print
+    print (
+        'There\'s also a large suite of tools to assist managing git '
+        'checkouts.\nSee \'man depot_tools\' (or read '
+        'depot_tools/man/html/depot_tools.html).')
+    print '-' * 80
 
 
 def upload_report(
     conf, report_url, verbose, push_works, push_log, push_duration_ms):
   """Posts report to the server, returns True if server accepted it.
 
   Uploads the report only if script is running in Google corp network. Otherwise
   just prints the report.
   """
   report = conf.copy()
@@ skipping 95 matching lines @@
       write_last_configuration(config)
     else:
       logging.warning('Check failed and will be retried on the next run')
   except Exception:
     logging.exception('Unexpected exception when performing git access check')
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))