Add a default Isolate gRPC proxy in config

appengine/swarming/handlers_bot.py

 # Copyright 2015 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.
 
 """Internal bot API handlers."""
 
 import base64
 import json
 import logging
 
@@ skipping 74 matching lines @@
 
   Do not warn about unexpected keys.
   """
   actual_keys = frozenset(actual_keys)
   missing = minimum_keys - actual_keys
   if missing:
     msg_missing = (' missing: %s' % sorted(missing)) if missing else ''
     return 'Unexpected %s%s; did you make a typo?' % (name, msg_missing)
 
 
-def get_bot_contact_server(request):
-  """Gets the server contacted by the bot.
-
-  Usually, this is the URL of the Swarming server itself, but if the bot
-  is communicating to the server by a gRPC intermediary, this will be the
-  IP address of the gRPC endpoint. The Native API will have an http or
-  https protocol, while gRPC endpoints will have a fake "grpc://" protocol.
-  This is to help consumers of this information (mainly the bot code
-  generators) distinguish between native and gRPC bots.
-  """
-  server = request.host_url
-  if 'luci-grpc' in request.headers:
-    server = 'grpc://%s' % request.headers['luci-grpc']
-  return server
-
-
 class _BotApiHandler(auth.ApiHandler):
   """Like ApiHandler, but also implements machine authentication."""
 
   # Bots are passing credentials through special headers (not cookies), no need
   # for XSRF tokens.
   xsrf_token_enforce_on = ()
 
   @classmethod
   def get_auth_methods(cls, conf):
     return [auth.machine_authentication, auth.oauth_authentication]
@@ skipping 46 matching lines @@
 
     # TODO(vadimsh): Remove is_ip_whitelisted_machine check once all bots are
     # using auth for bootstrap and updating.
     if (not acl.is_bootstrapper() and
         not acl.is_ip_whitelisted_machine() and
         not (bot_id and bot_auth.is_authenticated_bot(bot_id, machine_type))):
       raise auth.AuthorizationError('Not allowed to access the bot code')
 
     return bot_code.generate_bootstrap_token() if generate_token else None
 
-  def get_bot_contact_server(self):
-    """Gets the server contacted by the bot."""
-    return get_bot_contact_server(self.request)
-
 
 class BootstrapHandler(_BotAuthenticatingHandler):
   """Returns python code to run to bootstrap a swarming bot."""
 
   @auth.public  # auth inside check_bot_code_access()
   def get(self):
     # We must pass a bootstrap token (generating it, if necessary) to
     # get_bootstrap(...), since bootstrap.py uses tokens exclusively (it can't
     # transparently pass OAuth headers to /bot_code).
     bootstrap_token = self.check_bot_code_access(
         bot_id=None, generate_token=True)
     self.response.headers['Content-Type'] = 'text/x-python'
     self.response.headers['Content-Disposition'] = (
         'attachment; filename="swarming_bot_bootstrap.py"')
     self.response.out.write(
         bot_code.get_bootstrap(self.request.host_url, bootstrap_token).content)
 
 
 class BotCodeHandler(_BotAuthenticatingHandler):
   """Returns a zip file with all the files required by a bot.
 
   Optionally specify the hash version to download. If so, the returned data is
   cacheable.
   """
 
   @auth.public  # auth inside check_bot_code_access()
   def get(self, version=None):
-    server = self.get_bot_contact_server()
+    server = self.request.host_url
     self.check_bot_code_access(
         bot_id=self.request.get('bot_id'), generate_token=False)
     if version:
       expected, _ = bot_code.get_bot_version(server)
       if version != expected:
         # This can happen when the server is rapidly updated.
         logging.error('Requested Swarming bot %s, have %s', version, expected)
         self.abort(404)
       self.response.headers['Cache-Control'] = 'public, max-age=3600'
     else:
@@ skipping 157 matching lines @@
       return result
 
     # Look for admin enforced quarantine.
     if bool(bot_settings and bot_settings.quarantined):
       result.quarantined_msg = 'Quarantined by admin'
       return result
 
     task_queues.assert_bot(dimensions)
     return result
 
-  def get_bot_contact_server(self):
-    """Gets the server contacted by the bot."""
-    return get_bot_contact_server(self.request)
-
 
 class BotHandshakeHandler(_BotBaseHandler):
   """First request to be called to get initial data like bot code version.
 
   The bot is server-controlled so the server doesn't have to support multiple
   API version. When running a task, the bot sync the the version specific URL.
   Once a bot finishes its currently running task, it'll be immediately upgraded
   on its next poll.
 
   This endpoint does not return commands to the bot, for example to upgrade
@@ skipping 15 matching lines @@
     res = self._process()
     bot_management.bot_event(
         event_type='bot_connected', bot_id=res.bot_id,
         external_ip=self.request.remote_addr,
         authenticated_as=auth.get_peer_identity().to_bytes(),
         dimensions=res.dimensions, state=res.state,
         version=res.version, quarantined=bool(res.quarantined_msg),
         task_id='', task_name=None, message=res.quarantined_msg)
 
     data = {
-      'bot_version': bot_code.get_bot_version(self.get_bot_contact_server())[0],
+      'bot_version': bot_code.get_bot_version(self.request.host_url)[0],
       'server_version': utils.get_app_version(),
       'bot_group_cfg_version': res.bot_group_cfg.version,
       'bot_group_cfg': {
         # Let the bot know its server-side dimensions (from bots.cfg file).
         'dimensions': res.bot_group_cfg.dimensions,
       },
     }
     if res.bot_group_cfg.bot_config_script_content:
       logging.info(
           'Injecting %s: %d bytes',
@@ skipping 177 matching lines @@
           external_ip=self.request.remote_addr,
           authenticated_as=auth.get_peer_identity().to_bytes(),
           dimensions=res.dimensions, state=res.state,
           version=res.version, quarantined=quarantined,
           task_id=task_id, task_name=task_name, message=res.quarantined_msg)
 
     # Bot version is host-specific because the host URL is embedded in
     # swarming_bot.zip
     logging.debug('Fetching bot code version')
     expected_version, _ = bot_code.get_bot_version(
-        self.get_bot_contact_server())
+        self.request.host_url)
     if res.version != expected_version:
       bot_event('request_update')
       self._cmd_update(expected_version)
       return
     if quarantined:
       bot_event('request_sleep')
       self._cmd_sleep(sleep_streak, quarantined)
       return
 
     # If the server-side per-bot config for the bot has changed, we need
@@ skipping 435 matching lines @@
       ('/swarming/api/v1/bot/poll', BotPollHandler),
       ('/swarming/api/v1/bot/server_ping', ServerPingHandler),
       ('/swarming/api/v1/bot/task_update', BotTaskUpdateHandler),
       ('/swarming/api/v1/bot/task_update/<task_id:[a-f0-9]+>',
           BotTaskUpdateHandler),
       ('/swarming/api/v1/bot/task_error', BotTaskErrorHandler),
       ('/swarming/api/v1/bot/task_error/<task_id:[a-f0-9]+>',
           BotTaskErrorHandler),
   ]
   return [webapp2.Route(*i) for i in routes]