Add a default Isolate gRPC proxy in config

appengine/swarming/swarming_bot/bot_code/bot_main.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 """Swarming bot main process.
 
 This is the program that communicates with the Swarming server, ensures the code
 is always up to date and executes a child process to run tasks and upload
 results back.
 
@@ skipping 498 matching lines @@
     'dimensions': {u'id': ['none']},
     'state': {},
     'version': generate_version(),
   }
   base_dir = os.path.dirname(THIS_FILE)
   # Use temporary Bot object to call get_attributes. Attributes are needed to
   # construct the "real" bot.Bot.
   attributes = get_attributes(
     bot.Bot(
       remote_client.createRemoteClient(config['server'],
-                                       None, config['is_grpc']),
+                                       None, config.get('swarming_grpc_proxy')),
       attributes,
       config['server'],
       config['server_version'],
       base_dir,
       _on_shutdown_hook))
 
   # Make remote client callback use the returned bot object. We assume here
   # RemoteClient doesn't call its callback in the constructor (since 'botobj' is
   # undefined during the construction).
   botobj = bot.Bot(
       remote_client.createRemoteClient(
           config['server'],
           lambda: _get_authentication_headers(botobj),
-          config['is_grpc']),
+          config.get('swarming_grpc_proxy')),
       attributes,
       config['server'],
       config['server_version'],
       base_dir,
       _on_shutdown_hook)
   return botobj
 
 
 def _cleanup_bot_directory(botobj):
   """Delete anything not expected in the swarming bot directory.
@@ skipping 24 matching lines @@
   """Returns flags to pass to run_isolated.
 
   These are not meant to be processed by task_runner.py.
   """
   settings = _get_settings(botobj)
   partition = settings['free_partition']
   size = os_utilities.get_disk_size(THIS_FILE)
   min_free = (
       _min_free_disk({'size_mb': size}, partition) +
       partition['wiggle'])
-  return [
+  args = [
     '--cache', os.path.join(botobj.base_dir, 'isolated_cache'),
     '--min-free-space', str(min_free),
     '--named-cache-root', os.path.join(botobj.base_dir, 'c'),
     '--max-cache-size', str(settings['caches']['isolated']['size']),
     '--max-items', str(settings['caches']['isolated']['items']),
   ]
 
+  # Get the gRPC proxy from the config, but allow an environment variable to
+  # override.
+  grpc_proxy = get_config().get('isolate_grpc_proxy')
+  grpc_proxy = os.environ.get('ISOLATE_GRPC_PROXY', grpc_proxy)
+  if grpc_proxy is not None:
+    logging.info('Isolate will use gRPC proxy %s', grpc_proxy)
+    args.extend(['--grpc-proxy', grpc_proxy])
+  return args
+
 
 def _clean_cache(botobj):
   """Asks run_isolated to clean its cache.
 
   This may take a while but it ensures that in the case of a run_isolated run
   failed and it temporarily used more space than _min_free_disk, it can cleans
   up the mess properly.
 
   It will remove unexpected files, remove corrupted files, trim the cache size
   based on the policies and update state.json.
@@ skipping 101 matching lines @@
   config = get_config()
   if config['enable_ts_monitoring']:
     _init_ts_mon()
   try:
     # First thing is to get an arbitrary url. This also ensures the network is
     # up and running, which is necessary before trying to get the FQDN below.
     # There's no need to do error handling here - the "ping" is just to "wake
     # up" the network; if there's something seriously wrong, the handshake will
     # fail and we'll handle it there.
     remote = remote_client.createRemoteClient(config['server'], None,
-                                              config['is_grpc'])
+                                              config.get('swarming_grpc_proxy'))
     remote.ping()
   except Exception:
     # url_read() already traps pretty much every exceptions. This except
     # clause is kept there "just in case".
     logging.exception('server_ping threw')
 
   # If we are on GCE, we want to make sure GCE metadata server responds, since
   # we use the metadata to derive bot ID, dimensions and state.
   if platforms.is_gce():
     logging.info('Running on GCE, waiting for the metadata server')
@@ skipping 454 matching lines @@
   global _ERROR_HANDLER_WAS_REGISTERED
   try:
     with contextlib.closing(zipfile.ZipFile(THIS_FILE, 'r')) as f:
       config = json.load(f.open('config/config.json', 'r'))
     if config['server'].endswith('/'):
       raise ValueError('Invalid server entry %r' % config['server'])
   except (IOError, OSError, TypeError, ValueError):
     logging.exception('Invalid config.json!')
     config = {
       'enable_ts_monitoring': False,
-      'is_grpc': False,
       'server': '',
       'server_version': 'version1',
     }
   if not _ERROR_HANDLER_WAS_REGISTERED and config['server']:
     on_error.report_on_exception_exit(config['server'])
     _ERROR_HANDLER_WAS_REGISTERED = True
   return config
 
 
 def main(argv):
@@ skipping 30 matching lines @@
   error = None
   if len(args.unsupported) != 0:
     error = 'Unexpected arguments: %s' % args
   try:
     return _run_bot(error)
   finally:
     _call_hook_safe(
         True, bot.Bot(None, None, None, None, base_dir, None),
         'on_bot_shutdown')
     logging.info('main() returning')