Add automatic try server settings detection support.

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 sys
 import tempfile
 import traceback
 import urllib
 
 import gcl
 import gclient
 import upload
 
 __version__ = '1.1'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
-SCRIPT_PATH = os.path.join('tools', 'tryserver', 'tryserver.py')
 USAGE = r"""%prog [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
 to the server by HTTP.
 
 
 Examples:
   A git patch off a web site (git inserts a/ and b/) and fix the base dir:
     %prog --url http://url/to/patch.diff --patchlevel 1 --root src
@@ skipping 26 matching lines @@
     return None
   # If the root does not have a trailing \ or /, we add it so the returned path
   # starts immediately after the seperator regardless of whether it is provided.
   if not root.endswith(os.sep):
     root += os.sep
   return subpath[len(root):]
 
 
 def GetSourceRoot():
   """Returns the absolute directory one level up from the repository root."""
+  # TODO(maruel): This is odd to assume that '..' is the source root.
   return os.path.abspath(os.path.join(gcl.GetRepositoryRoot(), '..'))
 
 
-def ExecuteTryServerScript():
-  """Locates the tryserver script, executes it and returns its dictionary.
+def GetTryServerSettings():
+  """Grab try server settings local to the repository."""
+  def _SafeResolve(host):
+    try:
+      return socket.getaddrinfo(host, None)
+    except socket.gaierror:
+      return None
 
-  The try server script contains the repository-specific try server commands."""
-  script_locals = {}
-  try:
-    # gcl.GetRepositoryRoot() may throw an exception.
-    script_path = os.path.join(gcl.GetRepositoryRoot(), SCRIPT_PATH)
-  except Exception:
-    return script_locals
-  if os.path.exists(script_path):
-    try:
-      exec(gcl.ReadFile(script_path), script_locals)
-    except Exception, e:
-      # TODO(maruel):  Need to specialize the exception trapper.
-      traceback.print_exc()
-      raise InvalidScript('%s is invalid.' % script_path)
-  return script_locals
+  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')
+  # 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('.', '-')
 
 
 def RunCommand(command):
   output, retcode = gcl.RunShellWithReturnCode(command)
   if retcode:
     raise NoTryServerAccess(' '.join(command) + '\nOuput:\n' + output)
@@ skipping 140 matching lines @@
     values['patchlevel'] = options.patchlevel
   if options.issue:
     values['issue'] = options.issue
   if options.patchset:
     values['patchset'] = options.patchset
   return values
 
 
 def _SendChangeHTTP(options):
   """Send a change to the try server using the HTTP protocol."""
-  script_locals = ExecuteTryServerScript()
-
   if not options.host:
-    options.host = script_locals.get('try_server_http_host', None)
-    if not options.host:
-      raise NoTryServerAccess('Please use the --host option to specify the try '
-          'server host to connect to.')
+    raise NoTryServerAccess('Please use the --host option to specify the try '
+        'server host to connect to.')
   if not options.port:
-    options.port = script_locals.get('try_server_http_port', None)
-    if not options.port:
-      raise NoTryServerAccess('Please use the --port option to specify the try '
-          'server port to connect to.')
+    raise NoTryServerAccess('Please use the --port option to specify the try '
+        'server port to connect to.')
 
   values = _ParseSendChangeOptions(options)
   values['patch'] = options.diff
 
   url = 'http://%s:%s/send_try_patch' % (options.host, options.port)
   proxies = None
   if options.proxy:
     if options.proxy.lower() == 'none':
       # Effectively disable HTTP_PROXY or Internet settings proxy setup.
       proxies = {}
@@ skipping 10 matching lines @@
   if not connection:
     raise NoTryServerAccess('%s is unaccessible.' % url)
   if connection.read() != 'OK':
     raise NoTryServerAccess('%s is unaccessible.' % url)
   return options.name
 
 
 def _SendChangeSVN(options):
   """Send a change to the try server by committing a diff file on a subversion
   server."""
-  script_locals = ExecuteTryServerScript()
   if not options.svn_repo:
-    options.svn_repo = script_locals.get('try_server_svn', None)
-    if not options.svn_repo:
-      raise NoTryServerAccess('Please use the --svn_repo option to specify the'
-                              ' try server svn repository to connect to.')
+    raise NoTryServerAccess('Please use the --svn_repo option to specify the'
+                            ' try server svn repository to connect to.')
 
   values = _ParseSendChangeOptions(options)
   description = ''
   for (k,v) in values.iteritems():
     description += "%s=%s\n" % (k,v)
 
   # Do an empty checkout.
   temp_dir = tempfile.mkdtemp()
   temp_file = tempfile.NamedTemporaryFile()
   temp_file_name = temp_file.name
   try:
-    RunCommand(['svn', 'checkout', '--depth', 'empty', '--non-interactive',
+    # Don't use  '--non-interactive', since we want it to prompt for
+    # crendentials if necessary.
+    RunCommand(['svn', 'checkout', '--depth', 'empty',
                 options.svn_repo, temp_dir])
     # 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:
       RunCommand(['svn', 'ls', '--non-interactive', full_url])
@@ skipping 55 matching lines @@
       raise
 
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
 
 def TryChange(argv,
               file_list,
               swallow_exception,
               prog=None):
+  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('EMAIL_ADDRESS'),
                    help="Email address where to send the results. Use the "
@@ skipping 35 matching lines @@
   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")
   group.add_option("--patchlevel", type='int', metavar="LEVEL",
                    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=_SendChangeHTTP,
+  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,
+  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",
+  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 options.svn_repo:
-    options.send_patch = _SendChangeSVN
+
+  # Switch the default accordingly if there was no default send_patch.
+  if not options.send_patch:
+    if options.http_port and options.http_host:
+      options.send_patch = _SendChangeHTTP
+    elif options.svn_repo:
+      options.send_patch = _SendChangeSVN
 
   if len(args) == 1 and args[0] == 'help':
     parser.print_help()
   if (not options.files and (not options.issue and options.patchset) and
       not options.diff and not options.url):
     # TODO(maruel): It should just try the modified files showing up in a
     # svn status.
     print "Nothing to try, changelist is empty."
     return
 
@@ skipping 18 matching lines @@
     if patch_name == 'Unnamed':
       print "Note: use --name NAME to change the try's name."
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return
     print e
 
 
 if __name__ == "__main__":
   TryChange(None, None, False)