Revert of Upgrade 3rd packages

third_party/oauth2client/multistore_file.py

-# Copyright 2014 Google Inc. All rights reserved.
+# Copyright 2011 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,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Multi-credential file store with lock support.
 
 This module implements a JSON credential store where multiple
 credentials can be stored in one file. That file supports locking
 both in a single process and across processes.
 
 The credential themselves are keyed off of:
-
 * client_id
 * user_agent
 * scope
 
-The format of the stored data is like so::
-
-  {
-    'file_version': 1,
-    'data': [
-      {
-        'key': {
-          'clientId': '<client id>',
-          'userAgent': '<user agent>',
-          'scope': '<scope>'
-        },
-        'credential': {
-          # JSON serialized Credentials.
-        }
+The format of the stored data is like so:
+{
+  'file_version': 1,
+  'data': [
+    {
+      'key': {
+        'clientId': '<client id>',
+        'userAgent': '<user agent>',
+        'scope': '<scope>'
+      },
+      'credential': {
+        # JSON serialized Credentials.
       }
-    ]
-  }
-
+    }
+  ]
+}
 """
 
 __author__ = 'jbeda@google.com (Joe Beda)'
 
+import base64
 import errno
-import json
 import logging
 import os
 import threading
 
+from anyjson import simplejson
+from .client import Storage as BaseStorage
 from .client import Credentials
-from .client import Storage as BaseStorage
 from . import util
 from locked_file import LockedFile
 
 logger = logging.getLogger(__name__)
 
 # A dict from 'filename'->_MultiStore instances
 _multistores = {}
 _multistores_lock = threading.Lock()
 
 
 class Error(Exception):
   """Base error for this module."""
+  pass
 
 
 class NewerCredentialStoreError(Error):
-  """The credential store is a newer version than supported."""
+  """The credential store is a newer version that supported."""
+  pass
 
 
 @util.positional(4)
 def get_credential_storage(filename, client_id, user_agent, scope,
                            warn_on_readonly=True):
   """Get a Storage instance for a credential.
 
   Args:
     filename: The JSON file storing a set of credentials
     client_id: The client_id for the credential
@@ skipping 103 matching lines @@
 
 class _MultiStore(object):
   """A file backed store for multiple credentials."""
 
   @util.positional(2)
   def __init__(self, filename, warn_on_readonly=True):
     """Initialize the class.
 
     This will create the file if necessary.
     """
-    self._file = LockedFile(filename, 'r+', 'r')
+    self._file = LockedFile(filename, 'r+b', 'rb')
     self._thread_lock = threading.Lock()
     self._read_only = False
     self._warn_on_readonly = warn_on_readonly
 
     self._create_file_if_needed()
 
     # Cache of deserialized store. This is only valid after the
     # _MultiStore is locked or _refresh_data_cache is called. This is
     # of the form of:
     #
@@ skipping 57 matching lines @@
       """
       self._multistore._delete_credential(self._key)
 
   def _create_file_if_needed(self):
     """Create an empty file if necessary.
 
     This method will not initialize the file. Instead it implements a
     simple version of "touch" to ensure the file has been created.
     """
     if not os.path.exists(self._file.filename()):
-      old_umask = os.umask(0o177)
+      old_umask = os.umask(0177)
       try:
         open(self._file.filename(), 'a+b').close()
       finally:
         os.umask(old_umask)
 
   def _lock(self):
     """Lock the entire multistore."""
     self._thread_lock.acquire()
-    try:
-      self._file.open_and_lock()
-    except IOError as e:
-      if e.errno == errno.ENOSYS:
-        logger.warn('File system does not support locking the credentials '
-                    'file.')
-      elif e.errno ==  errno.ENOLCK:
-        logger.warn('File system is out of resources for writing the '
-                    'credentials file (is your disk full?).')
-      else:
-        raise
+    self._file.open_and_lock()
     if not self._file.is_locked():
       self._read_only = True
       if self._warn_on_readonly:
         logger.warn('The credentials file (%s) is not writable. Opening in '
                     'read-only mode. Any refreshed credentials will only be '
-                    'valid for this run.', self._file.filename())
+                    'valid for this run.' % self._file.filename())
     if os.path.getsize(self._file.filename()) == 0:
       logger.debug('Initializing empty multistore file')
       # The multistore is empty so write out an empty file.
       self._data = {}
       self._write()
     elif not self._read_only or self._data is None:
       # Only refresh the data if we are read/write or we haven't
       # cached the data yet. If we are readonly, we assume is isn't
       # changing out from under us and that we only have to read it
       # once. This prevents us from whacking any new access keys that
       # we have cached in memory but were unable to write out.
       self._refresh_data_cache()
 
   def _unlock(self):
     """Release the lock on the multistore."""
     self._file.unlock_and_close()
     self._thread_lock.release()
 
   def _locked_json_read(self):
     """Get the raw content of the multistore file.
 
     The multistore must be locked when this is called.
 
     Returns:
       The contents of the multistore decoded as JSON.
     """
     assert self._thread_lock.locked()
     self._file.file_handle().seek(0)
-    return json.load(self._file.file_handle())
+    return simplejson.load(self._file.file_handle())
 
   def _locked_json_write(self, data):
     """Write a JSON serializable data structure to the multistore.
 
     The multistore must be locked when this is called.
 
     Args:
       data: The data to be serialized and written.
     """
     assert self._thread_lock.locked()
     if self._read_only:
       return
     self._file.file_handle().seek(0)
-    json.dump(data, self._file.file_handle(), sort_keys=True, indent=2, separators=(',', ': '))
+    simplejson.dump(data, self._file.file_handle(), sort_keys=True, indent=2)
     self._file.file_handle().truncate()
 
   def _refresh_data_cache(self):
     """Refresh the contents of the multistore.
 
     The multistore must be locked when this is called.
 
     Raises:
       NewerCredentialStoreError: Raised when a newer client has written the
         store.
@@ skipping 37 matching lines @@
     Args:
       cred_entry: A dict entry from the data member of our format
 
     Returns:
       (key, cred) where the key is the key tuple and the cred is the
         OAuth2Credential object.
     """
     raw_key = cred_entry['key']
     key = util.dict_to_tuple_key(raw_key)
     credential = None
-    credential = Credentials.new_from_json(json.dumps(cred_entry['credential']))
+    credential = Credentials.new_from_json(simplejson.dumps(cred_entry['credential']))
     return (key, credential)
 
   def _write(self):
     """Write the cached data back out.
 
     The multistore must be locked.
     """
     raw_data = {'file_version': 1}
     raw_creds = []
     raw_data['data'] = raw_creds
     for (cred_key, cred) in self._data.items():
       raw_key = dict(cred_key)
-      raw_cred = json.loads(cred.to_json())
+      raw_cred = simplejson.loads(cred.to_json())
       raw_creds.append({'key': raw_key, 'credential': raw_cred})
     self._locked_json_write(raw_data)
 
   def _get_all_credential_keys(self):
     """Gets all the registered credential keys in the multistore.
 
     Returns:
       A list of dictionaries corresponding to all the keys currently registered
     """
     return [dict(key) for key in self._data.keys()]
@@ skipping 41 matching lines @@
     """Get a Storage object to get/set a credential.
 
     This Storage is a 'view' into the multistore.
 
     Args:
       key: The key used to retrieve the credential
 
     Returns:
       A Storage object that can be used to get/set this cred
     """
-    return self._Storage(self, key)
+    return self._Storage(self, key)