Upgrade gsutil to 3.4

third_party/gsutil/oauth2_plugin/oauth2_client.py

 # Copyright 2010 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 24 matching lines @@
 #   encapsulates both refresh and access tokens).
 
 
 import cgi
 import datetime
 import errno
 from hashlib import sha1
 import logging
 import os
 import tempfile
+import threading
 import urllib
 import urllib2
 import urlparse
 
 from boto import cacerts
 from third_party import fancy_urllib
 
 try:
   import json
 except ImportError:
   try:
     # Try to import from django, should work on App Engine
     from django.utils import simplejson as json
   except ImportError:
     # Try for simplejson
     import simplejson as json
 
 LOG = logging.getLogger('oauth2_client')
+# Lock used for checking/exchanging refresh token, so multithreaded
+# operation doesn't attempt concurrent refreshes.
+token_exchange_lock = threading.Lock()
 
 # SHA1 sum of the CA certificates file imported from boto.
 CACERTS_FILE_SHA1SUM = 'ed024a78d9327f8669b3b117d9eac9e3c9460e9b'
 
 class Error(Exception):
   """Base exception for the OAuth2 module."""
   pass
 
 
 class AccessTokenRefreshError(Error):
@@ skipping 285 matching lines @@
     found, the client obtains a fresh access token for the provided refresh
     token from the OAuth2 provider's token endpoint.
 
     Args:
       refresh_token: The RefreshToken object which to get an access token for.
     Returns:
       The cached or freshly obtained AccessToken.
     Raises:
       AccessTokenRefreshError if an error occurs.
     """
-    cache_key = refresh_token.CacheKey()
-    LOG.info('GetAccessToken: checking cache for key %s', cache_key)
-    access_token = self.access_token_cache.GetToken(cache_key)
-    LOG.debug('GetAccessToken: token from cache: %s', access_token)
-    if access_token is None or access_token.ShouldRefresh():
-      LOG.info('GetAccessToken: fetching fresh access token...')
-      access_token = self.FetchAccessToken(refresh_token)
-      LOG.debug('GetAccessToken: fresh access token: %s', access_token)
-      self.access_token_cache.PutToken(cache_key, access_token)
-    return access_token
+    # Ensure only one thread at a time attempts to get (and possibly refresh)
+    # the access token. This doesn't prevent concurrent refresh attempts across
+    # multiple gsutil instances, but at least protects against multiple threads
+    # simultaneously attempting to refresh when gsutil -m is used.
+    token_exchange_lock.acquire()
+    try:
+      cache_key = refresh_token.CacheKey()
+      LOG.info('GetAccessToken: checking cache for key %s', cache_key)
+      access_token = self.access_token_cache.GetToken(cache_key)
+      LOG.debug('GetAccessToken: token from cache: %s', access_token)
+      if access_token is None or access_token.ShouldRefresh():
+        LOG.info('GetAccessToken: fetching fresh access token...')
+        access_token = self.FetchAccessToken(refresh_token)
+        LOG.debug('GetAccessToken: fresh access token: %s', access_token)
+        self.access_token_cache.PutToken(cache_key, access_token)
+      return access_token
+    finally:
+      token_exchange_lock.release()
 
   def FetchAccessToken(self, refresh_token):
     """Fetches an access token from the provider's token endpoint.
 
     Given a RefreshToken, fetches an access token from this client's OAuth2
     provider's token endpoint.
 
     Args:
       refresh_token: The RefreshToken object which to get an access token for.
     Returns:
       The fetched AccessToken.
     Raises:
       AccessTokenRefreshError: if an error occurs.
     """
     request = {
         'grant_type': 'refresh_token',
         'client_id': self.client_id,
         'client_secret': self.client_secret,
         'refresh_token': refresh_token.refresh_token,
         }
     LOG.debug('FetchAccessToken request: %s', request)
 
     response, error = self._TokenRequest(request)
     LOG.debug(
         'FetchAccessToken response (error = %s): %s', error, response)
 
     if error:
       oauth2_error = ''
       if response and response['error']:
-        oauth2_error = '; OAuth2 error: %s', response['error']
+        oauth2_error = '; OAuth2 error: %s' % response['error']
       raise AccessTokenRefreshError(
           'Failed to exchange refresh token into access token; '
-          'request failed: %s%s', error, oauth2_error)
+          'request failed: %s%s' % (error, oauth2_error))
 
     if 'access_token' not in response:
       raise AccessTokenRefreshError(
-          'Failed to exchange refresh token into access token; response: %s',
+          'Failed to exchange refresh token into access token; response: %s' %
           response)
 
     token_expiry = None
     if 'expires_in' in response:
       token_expiry = (
           self.datetime_strategy.utcnow() +
           datetime.timedelta(seconds=int(response['expires_in'])))
 
     return AccessToken(response['access_token'], token_expiry,
                        datetime_strategy=self.datetime_strategy)
@@ skipping 70 matching lines @@
     LOG.debug('ExchangeAuthorizationCode request: %s', request)
 
     response, error = self._TokenRequest(request)
     LOG.debug(
         'ExchangeAuthorizationCode response (error = %s): %s',
         error, response)
 
     if error:
       oauth2_error = ''
       if response and response['error']:
-        oauth2_error = '; OAuth2 error: %s', response['error']
+        oauth2_error = '; OAuth2 error: %s' % response['error']
       raise AuthorizationCodeExchangeError(
           'Failed to exchange refresh token into access token; '
-          'request failed: %s%s', error, oauth2_error)
+          'request failed: %s%s' % (str(error), oauth2_error))
 
     if not 'access_token' in response:
       raise AuthorizationCodeExchangeError(
           'Failed to exchange authorization code into access token; '
-          'response: %s', response)
+          'response: %s' % response)
 
     token_expiry = None
     if 'expires_in' in response:
       token_expiry = (
           self.datetime_strategy.utcnow() +
           datetime.timedelta(seconds=int(response['expires_in'])))
 
     access_token = AccessToken(response['access_token'], token_expiry,
                                datetime_strategy=self.datetime_strategy)
 
@@ skipping 92 matching lines @@
     h.update(self.refresh_token)
     return h.hexdigest()
 
   def GetAuthorizationHeader(self):
     """Gets the access token HTTP authorication header value.
 
     Returns:
       The value of an Authorization HTTP header that authenticates
       requests with an OAuth2 access token based on this refresh token.
     """
-    return 'OAuth %s' % self.oauth2_client.GetAccessToken(self).token
+    return 'Bearer %s' % self.oauth2_client.GetAccessToken(self).token