Add 'mint_oauth_token' method to RPC client.

appengine/swarming/swarming_bot/bot_code/remote_client_grpc.py

 # Copyright 2016 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.
 
 # This is a reimplementation of RemoteClientNative but it uses (will use)
 # a gRPC method to communicate with a server instead of REST.
 
 import copy
 import json
 import logging
 import time
 
 import grpc
 import google.protobuf.json_format
 from proto_bot import swarming_bot_pb2
 from remote_client_errors import InternalError
+from remote_client_errors import MintOAuthTokenError
 from remote_client_errors import PollError
 from utils import net
 
 
 # How long to wait for a response from the server. Keeping the same as
 # the equivalent in remote_client.py for now.
 NET_CONNECTION_TIMEOUT_SEC = 5*60
 
 
 # How many times to retry a gRPC call
@@ skipping 161 matching lines @@
     logging.info('Updating to version: %s', bot_version)
     request = swarming_bot_pb2.BotUpdateRequest()
     request.bot_version = bot_version
     response = call_grpc(self._stub.BotUpdate, request)
     with open(new_zip_fn, 'wb') as f:
       f.write(response.bot_code)
 
   def ping(self):
     pass
 
+  def mint_oauth_token(self, task_id, bot_id, account_id, scopes):
+    # pylint: disable=unused-argument
+    raise MintOAuthTokenError(
+        'mint_oauth_token is not supported in grpc protocol')
+
 
 def create_state_proto(state_dict, message):
   """ Constructs a State message out of a state dict.
 
   Inspired by https://github.com/davyzhang/dict-to-protobuf, but all sub-dicts
   need to be encoded as google.protobuf.Structs because only Structs can handle
   free-form key-value pairs (and the mount points, for example, are not known
   at compile time).
 
   Why not use Struct for the *entire* message? It's because json_format.Parse
@@ skipping 38 matching lines @@
     except grpc.RpcError as g:
       if g.code() is not grpc.StatusCode.UNAVAILABLE:
         raise
       logging.warning('call_grpc - proxy is unavailable (attempt %d/%d)',
                       attempt, MAX_GRPC_ATTEMPTS)
       grpc_error = g
       time.sleep(net.calculate_sleep_before_retry(attempt, MAX_GRPC_SLEEP))
   # If we get here, it must be because we got (and saved) an error
   assert grpc_error is not None
   raise grpc_error