Revert of Upgrade 3rd packages

third_party/oauth2client/locked_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.
 
 """Locked file interface that should work on Unix and Windows pythons.
 
 This module first tries to use fcntl locking to ensure serialized access
 to a file, then falls back on a lock file if that is unavialable.
 
-Usage::
-
+Usage:
     f = LockedFile('filename', 'r+b', 'rb')
     f.open_and_lock()
     if f.is_locked():
-      print('Acquired filename with r+b mode')
+      print 'Acquired filename with r+b mode'
       f.file_handle().write('locked data')
     else:
-      print('Acquired filename with rb mode')
+      print 'Aquired filename with rb mode'
     f.unlock_and_close()
-
 """
 
-from __future__ import print_function
-
 __author__ = 'cache@google.com (David T McWherter)'
 
 import errno
 import logging
 import os
 import time
 
 from . import util
 
 logger = logging.getLogger(__name__)
@@ skipping 22 matching lines @@
     Args:
       filename: string, The pathname of the file.
       mode: string, The preferred mode to access the file with.
       fallback_mode: string, The mode to use if locking fails.
     """
     self._locked = False
     self._filename = filename
     self._mode = mode
     self._fallback_mode = fallback_mode
     self._fh = None
-    self._lock_fd = None
 
   def is_locked(self):
     """Was the file locked."""
     return self._locked
 
   def file_handle(self):
     """The file handle to the file. Valid only after opened."""
     return self._fh
 
   def filename(self):
@@ skipping 32 matching lines @@
       CredentialsFileSymbolicLinkError if the file is a symbolic link.
     """
     if self._locked:
       raise AlreadyLockedException('File %s is already locked' %
                                    self._filename)
     self._locked = False
 
     validate_file(self._filename)
     try:
       self._fh = open(self._filename, self._mode)
-    except IOError as e:
+    except IOError, e:
       # If we can't access with _mode, try _fallback_mode and don't lock.
       if e.errno == errno.EACCES:
         self._fh = open(self._filename, self._fallback_mode)
         return
 
     lock_filename = self._posix_lockfile(self._filename)
     start_time = time.time()
     while True:
       try:
         self._lock_fd = os.open(lock_filename,
                                 os.O_CREAT|os.O_EXCL|os.O_RDWR)
         self._locked = True
         break
 
-      except OSError as e:
+      except OSError, e:
         if e.errno != errno.EEXIST:
           raise
         if (time.time() - start_time) >= timeout:
-          logger.warn('Could not acquire lock %s in %s seconds',
-                      lock_filename, timeout)
+          logger.warn('Could not acquire lock %s in %s seconds' % (
+              lock_filename, timeout))
           # Close the file and open in fallback_mode.
           if self._fh:
             self._fh.close()
           self._fh = open(self._filename, self._fallback_mode)
           return
         time.sleep(delay)
 
   def unlock_and_close(self):
     """Unlock a file by removing the .lock file, and close the handle."""
     if self._locked:
@@ skipping 29 matching lines @@
         CredentialsFileSymbolicLinkError if the file is a symbolic link.
       """
       if self._locked:
         raise AlreadyLockedException('File %s is already locked' %
                                      self._filename)
       start_time = time.time()
 
       validate_file(self._filename)
       try:
         self._fh = open(self._filename, self._mode)
-      except IOError as e:
+      except IOError, e:
         # If we can't access with _mode, try _fallback_mode and don't lock.
-        if e.errno in (errno.EPERM, errno.EACCES):
+        if e.errno == errno.EACCES:
           self._fh = open(self._filename, self._fallback_mode)
           return
 
       # We opened in _mode, try to lock the file.
       while True:
         try:
           fcntl.lockf(self._fh.fileno(), fcntl.LOCK_EX)
           self._locked = True
           return
-        except IOError as e:
+        except IOError, e:
           # If not retrying, then just pass on the error.
           if timeout == 0:
-            raise
+            raise e
           if e.errno != errno.EACCES:
-            raise
+            raise e
           # We could not acquire the lock. Try again.
           if (time.time() - start_time) >= timeout:
-            logger.warn('Could not lock %s in %s seconds',
-                        self._filename, timeout)
+            logger.warn('Could not lock %s in %s seconds' % (
+                self._filename, timeout))
             if self._fh:
               self._fh.close()
             self._fh = open(self._filename, self._fallback_mode)
             return
           time.sleep(delay)
 
     def unlock_and_close(self):
       """Close and unlock the file using the fcntl.lockf primitive."""
       if self._locked:
         fcntl.lockf(self._fh.fileno(), fcntl.LOCK_UN)
@@ skipping 33 matching lines @@
         CredentialsFileSymbolicLinkError if the file is a symbolic link.
       """
       if self._locked:
         raise AlreadyLockedException('File %s is already locked' %
                                      self._filename)
       start_time = time.time()
 
       validate_file(self._filename)
       try:
         self._fh = open(self._filename, self._mode)
-      except IOError as e:
+      except IOError, e:
         # If we can't access with _mode, try _fallback_mode and don't lock.
         if e.errno == errno.EACCES:
           self._fh = open(self._filename, self._fallback_mode)
           return
 
       # We opened in _mode, try to lock the file.
       while True:
         try:
           hfile = win32file._get_osfhandle(self._fh.fileno())
           win32file.LockFileEx(
               hfile,
               (win32con.LOCKFILE_FAIL_IMMEDIATELY|
                win32con.LOCKFILE_EXCLUSIVE_LOCK), 0, -0x10000,
               pywintypes.OVERLAPPED())
           self._locked = True
           return
-        except pywintypes.error as e:
+        except pywintypes.error, e:
           if timeout == 0:
-            raise
+            raise e
 
           # If the error is not that the file is already in use, raise.
           if e[0] != _Win32Opener.FILE_IN_USE_ERROR:
             raise
 
           # We could not acquire the lock. Try again.
           if (time.time() - start_time) >= timeout:
             logger.warn('Could not lock %s in %s seconds' % (
                 self._filename, timeout))
             if self._fh:
               self._fh.close()
             self._fh = open(self._filename, self._fallback_mode)
             return
           time.sleep(delay)
 
     def unlock_and_close(self):
       """Close and unlock the file using the win32 primitive."""
       if self._locked:
         try:
           hfile = win32file._get_osfhandle(self._fh.fileno())
           win32file.UnlockFileEx(hfile, 0, -0x10000, pywintypes.OVERLAPPED())
-        except pywintypes.error as e:
+        except pywintypes.error, e:
           if e[0] != _Win32Opener.FILE_ALREADY_UNLOCKED_ERROR:
             raise
       self._locked = False
       if self._fh:
         self._fh.close()
 except ImportError:
   _Win32Opener = None
 
 
 class LockedFile(object):
@@ skipping 41 matching lines @@
       delay: float, The number of seconds to wait between retry attempts.
 
     Raises:
       AlreadyLockedException: if the lock is already acquired.
       IOError: if the open fails.
     """
     self._opener.open_and_lock(timeout, delay)
 
   def unlock_and_close(self):
     """Unlock and close a file."""
-    self._opener.unlock_and_close()
+    self._opener.unlock_and_close()