Make breakpad, gcl and presubmit_support dependencies optional

trychange.py

 #!/usr/bin/python
 # Copyright (c) 2009 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.
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
 import datetime
 import getpass
 import logging
 import optparse
 import os
 import shutil
 import socket
 import subprocess
 import sys
 import tempfile
 import urllib
 
-import breakpad
+try:
+  import breakpad
+except ImportError:
+  pass
 
-import gcl
 import gclient_utils
 import scm
-import presubmit_support
 
 __version__ = '1.2'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
 USAGE = r"""%prog [change_name] [options]
 
 Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
@@ skipping 20 matching lines @@
 class InvalidScript(Exception):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
 class NoTryServerAccess(Exception):
   def __str__(self):
     return self.args[0] + '\n' + HELP_STRING
 
 
-def GetTryServerSettings():
-  """Grab try server settings local to the repository."""
-  def _SafeResolve(host):
-    try:
-      return socket.getaddrinfo(host, None)
-    except socket.gaierror:
-      return None
-
-  settings = {}
-  settings['http_port'] = gcl.GetCodeReviewSetting('TRYSERVER_HTTP_PORT')
-  settings['http_host'] = gcl.GetCodeReviewSetting('TRYSERVER_HTTP_HOST')
-  settings['svn_repo'] = gcl.GetCodeReviewSetting('TRYSERVER_SVN_URL')
-  settings['default_project'] = gcl.GetCodeReviewSetting('TRYSERVER_PROJECT')
-  settings['default_root'] = gcl.GetCodeReviewSetting('TRYSERVER_ROOT')
-
-  # Pick a patchlevel, default to 0.
-  default_patchlevel = gcl.GetCodeReviewSetting('TRYSERVER_PATCHLEVEL')
-  if default_patchlevel:
-    default_patchlevel = int(default_patchlevel)
-  else:
-    default_patchlevel = 0
-  settings['default_patchlevel'] = default_patchlevel
-
-  # Use http is the http_host name resolve, fallback to svn otherwise.
-  if (settings['http_port'] and settings['http_host'] and
-      _SafeResolve(settings['http_host'])):
-    settings['default_transport'] = 'http'
-  elif settings.get('svn_repo'):
-    settings['default_transport'] = 'svn'
-  return settings
-
-
 def EscapeDot(name):
   return name.replace('.', '-')
 
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
   def __init__(self, options):
     self.options = options
 
   def GetFileNames(self):
@@ skipping 26 matching lines @@
       self.options.files = [f[1] for f in scm.SVN.CaptureStatus(None)]
     # Directories will return None so filter them out.
     diff = filter(None, [scm.SVN.DiffItem(f) for f in self.options.files])
     os.chdir(previous_cwd)
     return "".join(diff)
 
   def GetLocalRoot(self):
     """Return the path of the repository root."""
     return self.checkout_root
 
+  def GetBots(self):
+    try:
+      import gcl
+      return gcl.GetCachedFile('PRESUBMIT.py', use_root=True)
+    except ImportError:
+      try:
+        return gclient_utils.FileRead(os.path.join(self.checkout_root,
+                                                   'PRESUBMIT.py'))
+      except OSError:
+        return None
+
 
 class GIT(SCM):
   """Gathers the options and diff for a git checkout."""
   def __init__(self, *args, **kwargs):
     SCM.__init__(self, *args, **kwargs)
     self.checkout_root = os.path.abspath(
         gclient_utils.CheckCall(['git', 'rev-parse', '--show-cdup']).strip())
     if not self.options.diff:
       self.options.diff = self._GenerateDiff()
     if not self.options.name:
@@ skipping 21 matching lines @@
     if not branch.startswith('refs/heads/'):
       # TODO(maruel): Find a better type.
       raise NoTryServerAccess("Couldn't figure out branch name")
     branch = branch[len('refs/heads/'):]
     return branch
 
   def GetLocalRoot(self):
     """Return the path of the repository root."""
     return self.checkout_root
 
+  def GetBots(self):
+    try:
+      return gclient_utils.FileRead(os.path.join(self.checkout_root,
+                                                 'PRESUBMIT.py'))
+    except OSError:
+      return None
+
 
 def _ParseSendChangeOptions(options):
   """Parse common options passed to _SendChangeHTTP and _SendChangeSVN."""
   values = {}
   if options.email:
     values['email'] = options.email
   values['user'] = options.user
   values['name'] = options.name
   if options.bot:
     values['bot'] = ','.join(options.bot)
@@ skipping 66 matching lines @@
     description += "%s=%s\n" % (k,v)
 
   # Do an empty checkout.
   temp_dir = tempfile.mkdtemp()
   temp_file = tempfile.NamedTemporaryFile()
   try:
     try:
       command = ['svn', 'checkout', '--depth', 'empty', '-q',
                  options.svn_repo, temp_dir]
       if options.email:
-        command += ['--username', options.email]
+        command.extend(['--username', options.email])
       gclient_utils.CheckCall(command)
 
       # TODO(maruel): Use a subdirectory per user?
       current_time = str(datetime.datetime.now()).replace(':', '.')
       file_name = (EscapeDot(options.user) + '.' + EscapeDot(options.name) +
                    '.%s.diff' % current_time)
       full_path = os.path.join(temp_dir, file_name)
       full_url = options.svn_repo + '/' + file_name
       file_found = False
       try:
-        gclient_utils.CheckCall(['svn', 'ls', full_url])
+        gclient_utils.CheckCall(['svn', 'ls', full_url], print_error=False)
         file_found = True
       except gclient_utils.CheckCallError:
         pass
       if file_found:
         # The file already exists in the repo. Note that commiting a file is a
         # no-op if the file's content (the diff) is not modified. This is why
         # the file name contains the date and time.
-        gclient_utils.CheckCall(['svn', 'update', full_path])
-        f = open(full_path, 'wb')
-        f.write(options.diff)
-        f.close()
+        gclient_utils.CheckCall(['svn', 'update', full_path],
+                                print_error=False)
+        gclient_utils.FileWrite(full_path, options.diff, 'wb')
       else:
-        # Add the file to the repo
-        f = open(full_path, 'wb')
-        f.write(options.diff)
-        f.close()
-        gclient_utils.CheckCall(["svn", "add", full_path])
+        # Add the file to the repo.
+        gclient_utils.FileWrite(full_path, options.diff, 'wb')
+        gclient_utils.CheckCall(["svn", "add", full_path], print_error=False)
       temp_file.write(description)
       temp_file.flush()
       gclient_utils.CheckCall(["svn", "commit", full_path, '--file',
-                               temp_file.name])
+                               temp_file.name], print_error=False)
     except gclient_utils.CheckCallError, e:
       raise NoTryServerAccess(' '.join(e.command) + '\nOuput:\n' +
                               e.stdout)
   finally:
     temp_file.close()
     shutil.rmtree(temp_dir, True)
 
 
 def GuessVCS(options):
   """Helper to guess the version control system.
@@ skipping 30 matching lines @@
 def TryChange(argv,
               file_list,
               swallow_exception,
               prog=None):
   """
   Args:
     argv: Arguments and options.
     file_list: Default value to pass to --file.
     swallow_exception: Whether we raise or swallow exceptions.
   """
-  default_settings = GetTryServerSettings()
-  transport_functions = { 'http': _SendChangeHTTP, 'svn': _SendChangeSVN }
-  default_transport = transport_functions.get(
-      default_settings.get('default_transport'))
-
   # Parse argv
   parser = optparse.OptionParser(usage=USAGE,
                                  version=__version__,
                                  prog=prog)
 
   group = optparse.OptionGroup(parser, "Result and status")
   group.add_option("-u", "--user", default=getpass.getuser(),
                    help="Owner user name [default: %default]")
   group.add_option("-e", "--email",
                    default=os.environ.get('TRYBOT_RESULTS_EMAIL_ADDRESS',
@@ skipping 19 matching lines @@
                     help="Revision to use for the try job; default: the "
                          "revision will be determined by the try server; see "
                          "its waterfall for more info")
   group.add_option("-c", "--clobber", action="store_true",
                     help="Force a clobber before building; e.g. don't do an "
                          "incremental build")
   # TODO(maruel): help="Select a specific configuration, usually 'debug' or "
   #                    "'release'"
   group.add_option("--target", help=optparse.SUPPRESS_HELP)
 
-  # TODO(bradnelson): help="Override which project to use"
-  group.add_option("--project", help=optparse.SUPPRESS_HELP,
-                   default=default_settings['default_project'])
+  group.add_option("--project",
+                   help="Override which project to use")
 
   # Override the list of tests to run, use multiple times to list many tests
   # (or comma separated)
   group.add_option("-t", "--tests", action="append",
                    help=optparse.SUPPRESS_HELP)
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Patch to run")
   group.add_option("-f", "--file", default=file_list, dest="files",
                    metavar="FILE", action="append",
                    help="Use many times to list the files to include in the "
                         "try, relative to the repository root")
   group.add_option("--diff",
                    help="File containing the diff to try")
   group.add_option("--url",
                    help="Url where to grab a patch")
   group.add_option("--root",
                    help="Root to use for the patch; base subdirectory for "
-                        "patch created in a subdirectory",
-                   default=default_settings["default_root"])
+                        "patch created in a subdirectory")
   group.add_option("--patchlevel", type='int', metavar="LEVEL",
-                   help="Used as -pN parameter to patch",
-                   default=default_settings["default_patchlevel"])
+                   help="Used as -pN parameter to patch")
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Access the try server by HTTP")
   group.add_option("--use_http",
                    action="store_const",
                    const=_SendChangeHTTP,
                    dest="send_patch",
-                   default=default_transport,
                    help="Use HTTP to talk to the try server [default]")
   group.add_option("--host",
-                   default=default_settings['http_host'],
                    help="Host address")
   group.add_option("--port",
-                   default=default_settings['http_port'],
                    help="HTTP port")
   group.add_option("--proxy",
                    help="HTTP proxy")
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Access the try server with SVN")
   group.add_option("--use_svn",
                    action="store_const",
                    const=_SendChangeSVN,
                    dest="send_patch",
                    help="Use SVN to talk to the try server")
   group.add_option("--svn_repo",
                    metavar="SVN_URL",
-                   default=default_settings['svn_repo'],
                    help="SVN url to use to write the changes in; --use_svn is "
                         "implied when using --svn_repo")
   parser.add_option_group(group)
 
   options, args = parser.parse_args(argv)
 
   # Switch the default accordingly if there was no default send_patch.
   if not options.send_patch:
     if options.port and options.host:
       options.send_patch = _SendChangeHTTP
@@ skipping 20 matching lines @@
     try:
       options.scm = GuessVCS(options)
     except NoTryServerAccess, e:
       # If we got the diff, we don't care.
       if not options.diff:
         # TODO(maruel): Raise what?
         raise
 
     # Get try slaves from PRESUBMIT.py files if not specified.
     if not options.bot:
-      if options.url:
-        parser.error('You need to specify which bots to use.')
-      root_presubmit = gcl.GetCachedFile('PRESUBMIT.py', use_root=True)
-      options.bot = presubmit_support.DoGetTrySlaves(options.scm.GetFileNames(),
-                                                     options.scm.GetLocalRoot(),
-                                                     root_presubmit,
-                                                     False,
-                                                     sys.stdout)
+      # Even if the diff comes from options.url, use the local checkout for bot
+      # selection.
+      try:
+        # Get try slaves from PRESUBMIT.py files if not specified.
+        import presubmit_support
+        root_presubmit = options.scm.GetBots()
+        options.bot = presubmit_support.DoGetTrySlaves(
+            options.scm.GetFileNames(),
+            options.scm.GetLocalRoot(),
+            root_presubmit,
+            False,
+            sys.stdout)
+      except ImportError:
+        pass
+      # If no bot is specified, either the default pool will be selected or the
+      # try server will refuse the job. Either case we don't need to interfere.
 
     if options.name is None:
       if options.issue:
         options.name = 'Issue %s' % options.issue
       else:
         options.name = 'Unnamed'
         print('Note: use --name NAME to change the try job name.')
     if not options.email:
       print('Warning: TRYBOT_RESULTS_EMAIL_ADDRESS is not set. Try server '
             'results might\ngo to: %s@google.com.\n' % options.user)
     else:
       print('Results will be emailed to: ' + options.email)
 
     # Send the patch.
     options.send_patch(options)
     print 'Patch \'%s\' sent to try server: %s' % (options.name,
                                                    ', '.join(options.bot))
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return 1
     print e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(TryChange(None, [], False))