Check binary existence in gclient: 2nd try.

gclient_scm.py

 # Copyright (c) 2012 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 67 matching lines @@
 
 def CreateSCM(url, root_dir=None, relpath=None):
   SCM_MAP = {
     'svn' : SVNWrapper,
     'git' : GitWrapper,
   }
 
   scm_name = GetScmName(url)
   if not scm_name in SCM_MAP:
     raise gclient_utils.Error('No SCM found for url %s' % url)
-  return SCM_MAP[scm_name](url, root_dir, relpath)
+  found_scm = SCM_MAP[scm_name](url, root_dir, relpath)
+  if not found_scm.BinaryExists():
+    raise gclient_utils.Error('%s command not found' % scm_name)
+  return found_scm
 
 
 # SCMWrapper base class
 
 class SCMWrapper(object):
   """Add necessary glue between all the supported SCM.
 
   This is the abstraction layer to bind to different SCM.
   """
   def __init__(self, url=None, root_dir=None, relpath=None):
     self.url = url
     self._root_dir = root_dir
     if self._root_dir:
       self._root_dir = self._root_dir.replace('/', os.sep)
     self.relpath = relpath
     if self.relpath:
       self.relpath = self.relpath.replace('/', os.sep)
     if self.relpath and self._root_dir:
       self.checkout_path = os.path.join(self._root_dir, self.relpath)
+    self._checker_command = 'help'
+    self._binary_name = None
+
+  def BinaryExists(self):

[M-A Ruel, 2012/04/17 12:15:55]

This function may be called over 100 times for a gclient checkout. On windows,
this can be a significant slow down. As such, I recommend making it a
@classmethod, have a class level variable to know if it was detected, default it
to None, and if cls._binary_exist is None:
  try:
    cls._binary_exist = gclient_utils.CheckCall(...)
  except OSError:
    cls._binary_exist = False
return cls._binary_exist

Note that scm.py already has a function to get the tool's version,
SVN.AssertVersion() and GIT.AssertVersion. It'd probably be better to call this
function, since it's called eventually and it's already caching its return
value.

[Jun Mukai, 2012/04/18 02:46:36]

Oh, got it.  Modified to use AssertVersion.

+    """Returns true if the command exists."""
+    # Do not call _Run() because this we don't want to leave any messages for
+    # this check.
+    try:
+      return gclient_utils.CheckCallAndFilter(
+          [self._binary_name, self._checker_command], print_stdout=False) == 0
+    except OSError:
+      return False
 
   def RunCommand(self, command, options, args, file_list=None):
     # file_list will have all files that are modified appended to it.
     if file_list is None:
       file_list = []
 
     commands = ['cleanup', 'update', 'updatesingle', 'revert',
                 'revinfo', 'status', 'diff', 'pack', 'runhooks']
 
     if not command in commands:
       raise gclient_utils.Error('Unknown command %s' % command)
 
     if not command in dir(self):
       raise gclient_utils.Error('Command %s not implemented in %s wrapper' % (
           command, self.__class__.__name__))
 
     return getattr(self, command)(options, args, file_list)
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
 
   def __init__(self, url=None, root_dir=None, relpath=None):
     """Removes 'git+' fake prefix from git URL."""
     if url.startswith('git+http://') or url.startswith('git+https://'):
       url = url[4:]
     SCMWrapper.__init__(self, url, root_dir, relpath)
+    self._binary_name = 'git'
 
   def GetRevisionDate(self, revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     # TODO(floitsch): get the time-stamp of the given revision and not just the
     # time-stamp of the currently checked out revision.
     return self._Capture(['log', '-n', '1', '--format=%ai'])
 
   @staticmethod
   def cleanup(options, args, file_list):
@@ skipping 607 matching lines @@
 
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
   def _Capture(self, args):
     return subprocess2.check_output(
-        ['git'] + args,
+        [self._binary_name] + args,
         stderr=subprocess2.PIPE,
         cwd=self.checkout_path).strip()
 
   def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('print_stdout', True)
     stdout = kwargs.get('stdout', sys.stdout)
     stdout.write('\n________ running \'git %s\' in \'%s\'\n' % (
                  ' '.join(args), kwargs['cwd']))
-    gclient_utils.CheckCallAndFilter(['git'] + args, **kwargs)
+    gclient_utils.CheckCallAndFilter([self._binary_name] + args, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
+  def __init__(self, url=None, root_dir=None, relpath=None):
+    SCMWrapper.__init__(self, url, root_dir, relpath)
+    self._binary_name = 'svn'
+
   def GetRevisionDate(self, revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     date = scm.SVN.Capture(
         ['propget', '--revprop', 'svn:date', '-r', revision],
         os.path.join(self.checkout_path, '.'))
     return date.strip()
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
@@ skipping 299 matching lines @@
           'correct.') % rev)
     return rev
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
 
   def _Run(self, args, options, **kwargs):
     """Runs a commands that goes to stdout."""
     kwargs.setdefault('cwd', self.checkout_path)
-    gclient_utils.CheckCallAndFilterAndHeader(['svn'] + args,
+    gclient_utils.CheckCallAndFilterAndHeader([self._binary_name] + args,
         always=options.verbose, **kwargs)
 
   def _RunAndGetFileList(self, args, options, file_list, cwd=None):
     """Runs a commands that goes to stdout and grabs the file listed."""
     cwd = cwd or self.checkout_path
     scm.SVN.RunAndGetFileList(
         options.verbose,
         args + ['--ignore-externals'],
         cwd=cwd,
         file_list=file_list)
@@ skipping 21 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command