Remove bad whitespaces

Merged vuolter/pyload@00288e6

1 files changed, 50 insertions, 50 deletions

diff --git a/module/lib/beaker/container.py b/module/lib/beaker/container.py
index 515e97af6..e7a938c6e 100644
--- a/module/lib/beaker/container.py
+++ b/module/lib/beaker/container.py
@@ -28,34 +28,34 @@ else:
 class NamespaceManager(object):
     """Handles dictionary operations and locking for a namespace of
     values.
-    
+
     The implementation for setting and retrieving the namespace data is
     handled by subclasses.
-    
+
     NamespaceManager may be used alone, or may be privately accessed by
     one or more Container objects.  Container objects provide per-key
     services like expiration times and automatic recreation of values.
-    
+
     Multiple NamespaceManagers created with a particular name will all
     share access to the same underlying datasource and will attempt to
     synchronize against a common mutex object.  The scope of this
     sharing may be within a single process or across multiple
     processes, depending on the type of NamespaceManager used.
-    
+
     The NamespaceManager itself is generally threadsafe, except in the
     case of the DBMNamespaceManager in conjunction with the gdbm dbm
     implementation.
 
     """
-    
+
     @classmethod
     def _init_dependencies(cls):
         pass
-        
+
     def __init__(self, namespace):
         self._init_dependencies()
         self.namespace = namespace
-        
+
     def get_creation_lock(self, key):
         raise NotImplementedError()
 
@@ -79,37 +79,37 @@ class NamespaceManager(object):
 
     def __getitem__(self, key):
         raise NotImplementedError()
-        
+
     def __setitem__(self, key, value):
         raise NotImplementedError()
-    
+
     def set_value(self, key, value, expiretime=None):
         """Optional set_value() method called by Value.
-        
+
         Allows an expiretime to be passed, for namespace
         implementations which can prune their collections
         using expiretime.
-        
+
         """
         self[key] = value
-        
+
     def __contains__(self, key):
         raise NotImplementedError()
 
     def __delitem__(self, key):
         raise NotImplementedError()
-    
+
     def keys(self):
         raise NotImplementedError()
-    
+
     def remove(self):
         self.do_remove()
-        
+
 
 class OpenResourceNamespaceManager(NamespaceManager):
     """A NamespaceManager where read/write operations require opening/
     closing of a resource which is possibly mutexed.
-    
+
     """
     def __init__(self, namespace):
         NamespaceManager.__init__(self, namespace)
@@ -133,13 +133,13 @@ class OpenResourceNamespaceManager(NamespaceManager):
         except:
             self.access_lock.release_read_lock()
             raise
-            
+
     def release_read_lock(self):
         try:
             self.close(checkcount = True)
         finally:
             self.access_lock.release_read_lock()
-        
+
     def acquire_write_lock(self, wait=True): 
         r = self.access_lock.acquire_write_lock(wait)
         try:
@@ -149,7 +149,7 @@ class OpenResourceNamespaceManager(NamespaceManager):
         except:
             self.access_lock.release_write_lock()
             raise
-            
+
     def release_write_lock(self): 
         try:
             self.close(checkcount=True)
@@ -258,7 +258,7 @@ class Value(object):
                 except KeyError:
                     # guard against un-mutexed backends raising KeyError
                     has_value = False
-                    
+
             if not self.createfunc:
                 raise KeyError(self.key)
         finally:
@@ -349,29 +349,29 @@ class Value(object):
 
 class AbstractDictionaryNSManager(NamespaceManager):
     """A subclassable NamespaceManager that places data in a dictionary.
-    
+
     Subclasses should provide a "dictionary" attribute or descriptor
     which returns a dict-like object.   The dictionary will store keys
     that are local to the "namespace" attribute of this manager, so
     ensure that the dictionary will not be used by any other namespace.
 
     e.g.::
-    
+
         import collections
         cached_data = collections.defaultdict(dict)
-        
+
         class MyDictionaryManager(AbstractDictionaryNSManager):
             def __init__(self, namespace):
                 AbstractDictionaryNSManager.__init__(self, namespace)
                 self.dictionary = cached_data[self.namespace]
-                
+
     The above stores data in a global dictionary called "cached_data",
     which is structured as a dictionary of dictionaries, keyed
     first on namespace name to a sub-dictionary, then on actual
     cache key to value.
-    
+
     """
-    
+
     def get_creation_lock(self, key):
         return NameLock(
             identifier="memorynamespace/funclock/%s/%s" % (self.namespace, key),
@@ -386,19 +386,19 @@ class AbstractDictionaryNSManager(NamespaceManager):
 
     def has_key(self, key): 
         return self.dictionary.__contains__(key)
-        
+
     def __setitem__(self, key, value):
         self.dictionary[key] = value
-    
+
     def __delitem__(self, key):
         del self.dictionary[key]
 
     def do_remove(self):
         self.dictionary.clear()
-        
+
     def keys(self):
         return self.dictionary.keys()
-    
+
 class MemoryNamespaceManager(AbstractDictionaryNSManager):
     namespaces = util.SyncDict()
 
@@ -411,7 +411,7 @@ class DBMNamespaceManager(OpenResourceNamespaceManager):
     def __init__(self, namespace, dbmmodule=None, data_dir=None, 
             dbm_dir=None, lock_dir=None, digest_filenames=True, **kwargs):
         self.digest_filenames = digest_filenames
-        
+
         if not dbm_dir and not data_dir:
             raise MissingCacheParameter("data_dir or dbm_dir is required")
         elif dbm_dir:
@@ -419,7 +419,7 @@ class DBMNamespaceManager(OpenResourceNamespaceManager):
         else:
             self.dbm_dir = data_dir + "/container_dbm"
         util.verify_directory(self.dbm_dir)
-        
+
         if not lock_dir and not data_dir:
             raise MissingCacheParameter("data_dir or lock_dir is required")
         elif lock_dir:
@@ -437,14 +437,14 @@ class DBMNamespaceManager(OpenResourceNamespaceManager):
                                       identifiers=[self.namespace],
                                       extension='.dbm',
                                       digest_filenames=self.digest_filenames)
-        
+
         debug("data file %s", self.file)
         self._checkfile()
 
     def get_access_lock(self):
         return file_synchronizer(identifier=self.namespace,
                                  lock_dir=self.lock_dir)
-                                 
+
     def get_creation_lock(self, key):
         return file_synchronizer(
                     identifier = "dbmcontainer/funclock/%s" % self.namespace, 
@@ -458,19 +458,19 @@ class DBMNamespaceManager(OpenResourceNamespaceManager):
             for ext in ('db', 'dat', 'pag', 'dir'):
                 if os.access(file + os.extsep + ext, os.F_OK):
                     return True
-                    
+
         return False
-    
+
     def _checkfile(self):
         if not self.file_exists(self.file):
             g = self.dbmmodule.open(self.file, 'c') 
             g.close()
-                
+
     def get_filenames(self):
         list = []
         if os.access(self.file, os.F_OK):
             list.append(self.file)
-            
+
         for ext in ('pag', 'dir', 'db', 'dat'):
             if os.access(self.file + os.extsep + ext, os.F_OK):
                 list.append(self.file + os.extsep + ext)
@@ -488,17 +488,17 @@ class DBMNamespaceManager(OpenResourceNamespaceManager):
         if self.dbm is not None:
             debug("closing dbm file %s", self.file)
             self.dbm.close()
-        
+
     def do_remove(self):
         for f in self.get_filenames():
             os.remove(f)
-        
+
     def __getitem__(self, key): 
         return cPickle.loads(self.dbm[key])
 
     def __contains__(self, key): 
         return self.dbm.has_key(key)
-        
+
     def __setitem__(self, key, value):
         self.dbm[key] = cPickle.dumps(value)
 
@@ -513,7 +513,7 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
     def __init__(self, namespace, data_dir=None, file_dir=None, lock_dir=None,
                  digest_filenames=True, **kwargs):
         self.digest_filenames = digest_filenames
-        
+
         if not file_dir and not data_dir:
             raise MissingCacheParameter("data_dir or file_dir is required")
         elif file_dir:
@@ -536,19 +536,19 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
                                       extension='.cache',
                                       digest_filenames=self.digest_filenames)
         self.hash = {}
-        
+
         debug("data file %s", self.file)
 
     def get_access_lock(self):
         return file_synchronizer(identifier=self.namespace,
                                  lock_dir=self.lock_dir)
-                                 
+
     def get_creation_lock(self, key):
         return file_synchronizer(
                 identifier = "filecontainer/funclock/%s" % self.namespace, 
                 lock_dir = self.lock_dir
                 )
-        
+
     def file_exists(self, file):
         return os.access(file, os.F_OK)
 
@@ -562,7 +562,7 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
             fh.close()
 
         self.flags = flags
-        
+
     def do_close(self):
         if self.flags == 'c' or self.flags == 'w':
             fh = open(self.file, 'wb')
@@ -571,7 +571,7 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
 
         self.hash = {}
         self.flags = None
-                
+
     def do_remove(self):
         try:
             os.remove(self.file)
@@ -580,13 +580,13 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
             # but client code has asked for a clear() operation...
             pass
         self.hash = {}
-        
+
     def __getitem__(self, key): 
         return self.hash[key]
 
     def __contains__(self, key): 
         return self.hash.has_key(key)
-        
+
     def __setitem__(self, key, value):
         self.hash[key] = value
 
@@ -602,7 +602,7 @@ class FileNamespaceManager(OpenResourceNamespaceManager):
 namespace_classes = {}
 
 ContainerContext = dict
-    
+
 class ContainerMeta(type):
     def __init__(cls, classname, bases, dict_):
         namespace_classes[cls] = cls.namespace_class