Always treat TokenError as fatal error.

client/utils/auth_server.py

 #!/usr/bin/env python
 # 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.
 
 import base64
 import BaseHTTPServer
 import collections
 import json
 import logging
 import os
 import re
 import SocketServer
 import sys
 import threading
 import time
 
 
 # OAuth access token with its expiration time.
 AccessToken = collections.namedtuple('AccessToken', [
   'access_token',  # urlsafe str with the token
   'expiry',        # expiration time as unix timestamp in seconds
 ])
 
 
 class TokenError(Exception):
-  """Raised by TokenProvider if the token can't be created.
+  """Raised by TokenProvider if the token can't be created (fatal error).
 
   See TokenProvider docs for more info.
   """
 
-  def __init__(self, code, msg, fatal=False):
+  def __init__(self, code, msg):
     super(TokenError, self).__init__(msg)
     self.code = code
-    self.fatal = fatal
 
 
 class RPCError(Exception):
   """Raised by LocalAuthServer RPC handlers to reply with HTTP error status."""
 
   def __init__(self, code, msg):
     super(RPCError, self).__init__(msg)
     self.code = code
 
 
 class TokenProvider(object):
   """Interface for an object that can create OAuth tokens on demand.
 
   Defined as a concrete class only for documentation purposes.
   """
 
   def generate_token(self, account_id, scopes):
     """Generates a new access token with given scopes.
 
     Will be called from multiple threads (possibly concurrently) whenever
     LocalAuthServer needs to refresh a token with particular scopes.
 
     Can rise RPCError exceptions. They will be immediately converted to
     corresponding RPC error replies (e.g. HTTP 500). This is appropriate for
     low-level or transient errors.
 
     Can also raise TokenError. It will be converted to GetOAuthToken reply with
-    non-zero error_code. It will also optionally be cached, so that the provider
-    would never be called again for the same set of scopes. This is appropriate
-    for high-level or fatal errors.
+    non-zero error_code. It will also be cached, so that the provider would
+    never be called again for the same set of scopes. This is appropriate for
+    high-level fatal errors.
 
     Returns AccessToken on success.
     """
     raise NotImplementedError()
 
 
 class LocalAuthServer(object):
   """LocalAuthServer handles /rpc/LuciLocalAuthService.* requests.
 
   It exposes an HTTP JSON RPC API that is used by task processes to grab an
@@ skipping 168 matching lines @@
     # Do the refresh outside of the RPC server lock to unblock other clients
     # that are hitting the cache. The token provider should implement its own
     # synchronization.
     if need_refresh:
       try:
         tok_or_err = token_provider.generate_token(account_id, scopes)
         assert isinstance(tok_or_err, AccessToken), tok_or_err
       except TokenError as exc:
         tok_or_err = exc
       # Cache the token or fatal errors (to avoid useless retry later).
-      if isinstance(tok_or_err, AccessToken) or tok_or_err.fatal:
-        with self._lock:
-          if not self._server:
-            raise RPCError(503, 'Stopped already.')
-          self._cache[cache_key] = tok_or_err
+      with self._lock:
+        if not self._server:
+          raise RPCError(503, 'Stopped already.')
+        self._cache[cache_key] = tok_or_err
 
     # Done.
     if isinstance(tok_or_err, AccessToken):
       return {
         'access_token': tok_or_err.access_token,
         'expiry': int(tok_or_err.expiry),
       }
     if isinstance(tok_or_err, TokenError):
       return {
         'error_code': tok_or_err.code,
@@ skipping 153 matching lines @@
       while True:
         time.sleep(1)
   except KeyboardInterrupt:
     pass
   finally:
     server.stop()
 
 
 if __name__ == '__main__':
   testing_main()