class Synchronizer(object): """ Class encapsulating a lock allowing it to be used as a synchronizing decorator making the call thread-safe""" def __init__(self, lockName="", recursive=False): from DIRAC.Core.Utilities.LockRing import LockRing self.__lockName = lockName self.__lr = LockRing() self.__lock = self.__lr.getLock(lockName, recursive=recursive) def __call__(self, funcToCall): def lockedFunc(*args, **kwargs): try: if self.__lockName: print("LOCKING", self.__lockName) self.__lock.acquire() return funcToCall(*args, **kwargs) finally: if self.__lockName: print("UNLOCKING", self.__lockName) self.__lock.release() return lockedFunc def lock(self): return self.__lock.acquire() def unlock(self): return self.__lock.release()
def __init__(self, loadDefaultCFG=True): envVar = os.environ.get("DIRAC_FEWER_CFG_LOCKS", "no").lower() self.__locksEnabled = envVar not in ("y", "yes", "t", "true", "on", "1") if self.__locksEnabled: lr = LockRing() self.threadingEvent = lr.getEvent() self.threadingEvent.set() self.threadingLock = lr.getLock() self.runningThreadsNumber = 0 self.__compressedConfigurationData = None self.configurationPath = "/DIRAC/Configuration" self.backupsDir = os.path.join(DIRAC.rootPath, "etc", "csbackup") self._isService = False self.localCFG = CFG() self.remoteCFG = CFG() self.mergedCFG = CFG() self.remoteServerList = [] if loadDefaultCFG: defaultCFGFile = os.path.join(DIRAC.rootPath, "etc", "dirac.cfg") gLogger.debug("dirac.cfg should be at", "%s" % defaultCFGFile) retVal = self.loadFile(defaultCFGFile) if not retVal["OK"]: gLogger.warn("Can't load %s file" % defaultCFGFile) self.sync()
class Synchronizer: """ Class encapsulating a lock allowing it to be used as a synchronizing decorator making the call thread-safe""" def __init__(self, lockName="", recursive=False): from DIRAC.Core.Utilities.LockRing import LockRing self.__lockName = lockName self.__lr = LockRing() self.__lock = self.__lr.getLock(lockName, recursive=recursive) def __call__(self, funcToCall): def lockedFunc(*args, **kwargs): try: if self.__lockName: print "LOCKING", self.__lockName self.__lock.acquire() return funcToCall(*args, **kwargs) finally: if self.__lockName: print "UNLOCKING", self.__lockName self.__lock.release() return lockedFunc def lock(self): return self.__lock.acquire() def unlock(self): return self.__lock.release()
def __init__( self, loadDefaultCFG = True ): lr = LockRing() self.threadingEvent = lr.getEvent() self.threadingEvent.set() self.threadingLock = lr.getLock() self.runningThreadsNumber = 0 self.compressedConfigurationData = "" self.configurationPath = "/DIRAC/Configuration" self.backupsDir = os.path.join( DIRAC.rootPath, "etc", "csbackup" ) self._isService = False self.localCFG = CFG() self.remoteCFG = CFG() self.mergedCFG = CFG() self.remoteServerList = [] if loadDefaultCFG: defaultCFGFile = os.path.join( DIRAC.rootPath, "etc", "dirac.cfg" ) gLogger.debug( "dirac.cfg should be at", "%s" % defaultCFGFile ) retVal = self.loadFile( defaultCFGFile ) if not retVal[ 'OK' ]: gLogger.warn( "Can't load %s file" % defaultCFGFile ) self.sync()
def __init__( self, loadDefaultCFG = True ): lr = LockRing() self.threadingEvent = lr.getEvent() self.threadingEvent.set() self.threadingLock = lr.getLock() self.runningThreadsNumber = 0 self.compressedConfigurationData = "" self.configurationPath = "/DIRAC/Configuration" self.backupsDir = os.path.join( DIRAC.rootPath, "etc", "csbackup" ) self._isService = False self.localCFG = CFG() self.remoteCFG = CFG() self.mergedCFG = CFG() self.remoteServerList = [] if loadDefaultCFG: defaultCFGFile = os.path.join( DIRAC.rootPath, "etc", "dirac.cfg" ) gLogger.debug( "dirac.cfg should be at", "%s" % defaultCFGFile ) retVal = self.loadFile( defaultCFGFile ) if not retVal[ 'OK' ]: gLogger.warn( "Can't load %s file" % defaultCFGFile ) self.sync()
class Cache(object): """ Cache basic class. WARNING: None of its methods is thread safe. Acquire / Release lock when using them ! """ def __init__(self, lifeTime, updateFunc): """ Constructor :Parameters: **lifeTime** - `int` Lifetime of the elements in the cache ( seconds ! ) **updateFunc** - `function` This function MUST return a S_OK | S_ERROR object. In the case of the first, its value must be a dictionary. """ # We set a 20% of the lifetime randomly, so that if we have thousands of jobs # starting at the same time, all the caches will not end at the same time. randomLifeTimeBias = 0.2 * random.random() self.log = gLogger.getSubLogger(self.__class__.__name__) self.__lifeTime = int(lifeTime * (1 + randomLifeTimeBias)) self.__updateFunc = updateFunc # The records returned from the cache must be valid at least 30 seconds. self.__validSeconds = 30 # Cache self.__cache = DictCache() self.__cacheLock = LockRing() self.__cacheLock.getLock(self.__class__.__name__) #............................................................................. # internal cache object getter def cacheKeys(self): """ Cache keys getter :returns: list with valid keys on the cache """ return self.__cache.getKeys(validSeconds=self.__validSeconds) #............................................................................. # acquire / release Locks def acquireLock(self): """ Acquires Cache lock """ self.__cacheLock.acquire(self.__class__.__name__) def releaseLock(self): """ Releases Cache lock """ self.__cacheLock.release(self.__class__.__name__) #............................................................................. # Cache getters def get(self, cacheKeys): """ Gets values for cacheKeys given, if all are found ( present on the cache and valid ), returns S_OK with the results. If any is not neither present not valid, returns S_ERROR. :Parameters: **cacheKeys** - `list` list of keys to be extracted from the cache :return: S_OK | S_ERROR """ result = {} for cacheKey in cacheKeys: cacheRow = self.__cache.get(cacheKey, validSeconds=self.__validSeconds) if not cacheRow: self.log.error(str(cacheKey)) return S_ERROR('Cannot get %s' % str(cacheKey)) result.update({cacheKey: cacheRow}) return S_OK(result) #............................................................................. # Cache refreshers def refreshCache(self): """ Purges the cache and gets fresh data from the update function. :return: S_OK | S_ERROR. If the first, its content is the new cache. """ self.log.verbose('refreshing...') self.__cache.purgeAll() newCache = self.__updateFunc() if not newCache['OK']: self.log.error(newCache['Message']) return newCache newCache = self.__updateCache(newCache['Value']) self.log.verbose('refreshed') return newCache #............................................................................. # Private methods def __updateCache(self, newCache): """ Given the new cache dictionary, updates the internal cache with it. It sets a duration to the entries of <self.__lifeTime> seconds. :Parameters: **newCache** - `dict` dictionary containing a new cache :return: dictionary. It is newCache argument. """ for cacheKey, cacheValue in newCache.items(): self.__cache.add(cacheKey, self.__lifeTime, value=cacheValue) # We are assuming nothing will fail while inserting in the cache. There is # no apparent reason to suspect from that piece of code. return S_OK(newCache)
class WORM(object): """ Write One - Read Many """ def __init__(self, maxReads=10): from DIRAC.Core.Utilities.LockRing import LockRing self.__lr = LockRing() self.__lock = self.__lr.getLock() self.__maxReads = maxReads self.__semaphore = threading.Semaphore(maxReads) def write(self, funcToCall): """ Write decorator """ def __doWriteLock(*args, **kwargs): try: self.__startWriteZone() return funcToCall(*args, **kwargs) finally: self.__endWriteZone() return __doWriteLock def read(self, funcToCall): """ Read decorator """ def __doReadLock(*args, **kwargs): try: self.__startReadZone() return funcToCall(*args, **kwargs) finally: self.__endReadZone() return __doReadLock def __startWriteZone(self): """ Locks Event to prevent further threads from reading. Stops current thread until no other thread is accessing. PRIVATE USE """ self.__lock.acquire() for i in range(self.__maxReads): self.__semaphore.acquire() self.__lock.release() def __endWriteZone(self): """ Unlocks Event. PRIVATE USE """ for i in range(self.__maxReads): self.__semaphore.release() def __startReadZone(self): """ Start of danger zone. This danger zone may be or may not be a mutual exclusion zone. Counter is maintained to know how many threads are inside and be able to enable and disable mutual exclusion. PRIVATE USE """ self.__semaphore.acquire() def __endReadZone(self): """ End of danger zone. PRIVATE USE """ self.__semaphore.release()
class Cache( object ): """ Cache basic class. WARNING: None of its methods is thread safe. Acquire / Release lock when using them ! """ def __init__( self, lifeTime, updateFunc ): """ Constructor :Parameters: **lifeTime** - `int` Lifetime of the elements in the cache ( seconds ! ) **updateFunc** - `function` This function MUST return a S_OK | S_ERROR object. In the case of the first, its value must be a dictionary. """ # We set a 20% of the lifetime randomly, so that if we have thousands of jobs # starting at the same time, all the caches will not end at the same time. randomLifeTimeBias = 0.2 * random.random() self.log = gLogger.getSubLogger( self.__class__.__name__ ) self.__lifeTime = int( lifeTime * ( 1 + randomLifeTimeBias ) ) self.__updateFunc = updateFunc # The records returned from the cache must be valid at least 10 seconds. self.__validSeconds = 10 # Cache self.__cache = DictCache() self.__cacheLock = LockRing() self.__cacheLock.getLock( self.__class__.__name__ ) #............................................................................. # internal cache object getter def cacheKeys( self ): """ Cache keys getter :returns: list with valid keys on the cache """ return self.__cache.getKeys( validSeconds = self.__validSeconds ) #............................................................................. # acquire / release Locks def acquireLock( self ): """ Acquires Cache lock """ self.__cacheLock.acquire( self.__class__.__name__ ) def releaseLock( self ): """ Releases Cache lock """ self.__cacheLock.release( self.__class__.__name__) #............................................................................. # Cache getters def get( self, cacheKeys ): """ Gets values for cacheKeys given, if all are found ( present on the cache and valid ), returns S_OK with the results. If any is not neither present not valid, returns S_ERROR. :Parameters: **cacheKeys** - `list` list of keys to be extracted from the cache :return: S_OK | S_ERROR """ result = {} for cacheKey in cacheKeys: cacheRow = self.__cache.get( cacheKey, validSeconds = self.__validSeconds ) if not cacheRow: self.log.error( str( cacheKey ) ) return S_ERROR( 'Cannot get %s' % str( cacheKey ) ) result.update( { cacheKey : cacheRow } ) return S_OK( result ) #............................................................................. # Cache refreshers def refreshCache( self ): """ Purges the cache and gets fresh data from the update function. :return: S_OK | S_ERROR. If the first, its content is the new cache. """ self.log.verbose( 'refreshing...' ) self.__cache.purgeAll() newCache = self.__updateFunc() if not newCache[ 'OK' ]: self.log.error( newCache[ 'Message' ] ) return newCache newCache = self.__updateCache( newCache[ 'Value' ] ) self.log.verbose( 'refreshed' ) return newCache #............................................................................. # Private methods def __updateCache( self, newCache ): """ Given the new cache dictionary, updates the internal cache with it. It sets a duration to the entries of <self.__lifeTime> seconds. :Parameters: **newCache** - `dict` dictionary containing a new cache :return: dictionary. It is newCache argument. """ for cacheKey, cacheValue in newCache.items(): self.__cache.add( cacheKey, self.__lifeTime, value = cacheValue ) # We are assuming nothing will fail while inserting in the cache. There is # no apparent reason to suspect from that piece of code. return S_OK( newCache )
class DictCache: def __init__( self, deleteFunction = False ): """ Initialize the dict cache. If a delete function is specified it will be invoked when deleting a cached object """ self.__lock = LockRing() self.__lock.getLock( self.__class__.__name__, recursive = True ) self.__cache = {} self.__deleteFunction = deleteFunction def exists( self, cKey, validSeconds = 0 ): """ Returns True/False if the key exists for the given number of seconds Arguments: - cKey : identification key of the record - validSeconds : The amount of seconds the key has to be valid for """ self.__lock.acquire( self.__class__.__name__ ) try: #Is the key in the cache? if cKey in self.__cache: expTime = self.__cache[ cKey ][ 'expirationTime' ] #If it's valid return True! if expTime > datetime.datetime.now() + datetime.timedelta( seconds = validSeconds ): return True else: #Delete expired self.delete( cKey ) return False finally: self.__lock.release( self.__class__.__name__ ) def delete( self, cKey ): """ Delete a key from the cache Arguments: - cKey : identification key of the record """ self.__lock.acquire( self.__class__.__name__ ) try: if cKey not in self.__cache: return if self.__deleteFunction: self.__deleteFunction( self.__cache[ cKey ][ 'value' ] ) del( self.__cache[ cKey ] ) finally: self.__lock.release( self.__class__.__name__ ) def add( self, cKey, validSeconds, value = None ): """ Add a record to the cache Arguments: - cKey : identification key of the record - validSeconds : valid seconds of this record - value : value of the record """ if max( 0, validSeconds ) == 0: return self.__lock.acquire( self.__class__.__name__ ) try: vD = { 'expirationTime' : datetime.datetime.now() + datetime.timedelta( seconds = validSeconds ), 'value' : value } self.__cache[ cKey ] = vD finally: self.__lock.release( self.__class__.__name__ ) def get( self, cKey, validSeconds = 0 ): """ Get a record from the cache Arguments: - cKey : identification key of the record - validSeconds : The amount of seconds the key has to be valid for """ self.__lock.acquire( self.__class__.__name__ ) try: #Is the key in the cache? if cKey in self.__cache: expTime = self.__cache[ cKey ][ 'expirationTime' ] #If it's valid return True! if expTime > datetime.datetime.now() + datetime.timedelta( seconds = validSeconds ): return self.__cache[ cKey ][ 'value' ] else: #Delete expired self.delete( cKey ) return False finally: self.__lock.release( self.__class__.__name__ ) def showContentsInString( self ): """ Return a human readable string to represent the contents """ self.__lock.acquire( self.__class__.__name__ ) try: data = [] for cKey in self.__cache: data.append( "%s:" % str( cKey ) ) data.append( "\tExp: %s" % self.__cache[ cKey ][ 'expirationTime' ] ) if self.__cache[ cKey ][ 'value' ]: data.append( "\tVal: %s" % self.__cache[ cKey ][ 'value' ] ) return "\n".join( data ) finally: self.__lock.release( self.__class__.__name__ ) def getKeys( self, validSeconds = 0 ): """ Get keys for all contents """ self.__lock.acquire( self.__class__.__name__ ) try: keys = [] limitTime = datetime.datetime.now() + datetime.timedelta( seconds = validSeconds ) for cKey in self.__cache: if self.__cache[ cKey ][ 'expirationTime' ] > limitTime: keys.append( cKey ) return keys finally: self.__lock.release( self.__class__.__name__ ) def purgeExpired( self, expiredInSeconds = 0 ): """ Purge all entries that are expired or will be expired in <expiredInSeconds> """ self.__lock.acquire( self.__class__.__name__ ) try: keys = [] limitTime = datetime.datetime.now() + datetime.timedelta( seconds = expiredInSeconds ) for cKey in self.__cache: if self.__cache[ cKey ][ 'expirationTime' ] < limitTime: keys.append( cKey ) for cKey in keys: if self.__deleteFunction: self.__deleteFunction( self.__cache[ cKey ][ 'value' ] ) del( self.__cache[ cKey ] ) finally: self.__lock.release( self.__class__.__name__ ) def purgeAll( self ): """ Purge all entries """ self.__lock.acquire( self.__class__.__name__ ) try: keys = self.__cache.keys() for cKey in keys: if self.__deleteFunction: self.__deleteFunction( self.__cache[ cKey ][ 'value' ] ) del( self.__cache[ cKey ] ) finally: self.__lock.release( self.__class__.__name__)
class WORM: """ Write One - Read Many """ def __init__(self, maxReads=10): from DIRAC.Core.Utilities.LockRing import LockRing self.__lr = LockRing() self.__lock = self.__lr.getLock() self.__maxReads = maxReads self.__semaphore = threading.Semaphore(maxReads) def write(self, funcToCall): """ Write decorator """ def __doWriteLock(*args, **kwargs): try: self.__startWriteZone() return funcToCall(*args, **kwargs) finally: self.__endWriteZone() return __doWriteLock def read(self, funcToCall): """ Read decorator """ def __doReadLock(*args, **kwargs): try: self.__startReadZone() return funcToCall(*args, **kwargs) finally: self.__endReadZone() return __doReadLock def __startWriteZone(self): """ Locks Event to prevent further threads from reading. Stops current thread until no other thread is accessing. PRIVATE USE """ self.__lock.acquire() for i in range(self.__maxReads): self.__semaphore.acquire() self.__lock.release() def __endWriteZone(self): """ Unlocks Event. PRIVATE USE """ for i in range(self.__maxReads): self.__semaphore.release() def __startReadZone(self): """ Start of danger zone. This danger zone may be or may not be a mutual exclusion zone. Counter is maintained to know how many threads are inside and be able to enable and disable mutual exclusion. PRIVATE USE """ self.__semaphore.acquire() def __endReadZone(self): """ End of danger zone. PRIVATE USE """ self.__semaphore.release()
class Cache: """ Cache basic class. WARNING: None of its methods is thread safe. Acquire / Release lock when using them ! """ def __init__(self, lifeTime, updateFunc): """ Constructor :Parameters: **lifeTime** - `int` Lifetime of the elements in the cache ( seconds ! ) **updateFunc** - `function` This function MUST return a S_OK | S_ERROR object. In the case of the first, its value must be a dictionary. """ # We set a 20% of the lifetime randomly, so that if we have thousands of jobs # starting at the same time, all the caches will not end at the same time. randomLifeTimeBias = 0.2 * random.random() self.log = gLogger.getSubLogger(self.__class__.__name__) self.__lifeTime = int(lifeTime * (1 + randomLifeTimeBias)) self.__updateFunc = updateFunc # The records returned from the cache must be valid at least 30 seconds. self.__validSeconds = 30 # Cache self.__cache = DictCache() self.__cacheLock = LockRing() self.__cacheLock.getLock(self.__class__.__name__) # internal cache object getter def cacheKeys(self): """ Cache keys getter :returns: list with keys in the cache valid for at least twice the validity period of the element """ # Here we need to have more than the validity period because of the logic of the matching: # * get all the keys with validity T # * for each key K, get the element K with validity T # This logic fails for elements just at the limit of the required time return self.__cache.getKeys(validSeconds=self.__validSeconds * 2) # acquire / release Locks def acquireLock(self): """ Acquires Cache lock """ self.__cacheLock.acquire(self.__class__.__name__) def releaseLock(self): """ Releases Cache lock """ self.__cacheLock.release(self.__class__.__name__) # Cache getters def get(self, cacheKeys): """ Gets values for cacheKeys given, if all are found ( present on the cache and valid ), returns S_OK with the results. If any is not neither present not valid, returns S_ERROR. :Parameters: **cacheKeys** - `list` list of keys to be extracted from the cache :return: S_OK | S_ERROR """ result = {} for cacheKey in cacheKeys: cacheRow = self.__cache.get(cacheKey, validSeconds=self.__validSeconds) if not cacheRow: return S_ERROR("Cannot get %s" % str(cacheKey)) result.update({cacheKey: cacheRow}) return S_OK(result) def check(self, cacheKeys, vO): """ Modified get() method. Attempts to find keys with a vO value appended or 'all' value appended. The cacheKeys passed in are 'flattened' cache keys (no vO) Gets values for cacheKeys given, if all are found ( present on the cache and valid ), returns S_OK with the results. If any is not neither present not valid, returns S_ERROR. :Parameters: **cacheKeys** - `list` list of keys to be extracted from the cache :return: S_OK | S_ERROR """ result = {} for cacheKey in cacheKeys: longCacheKey = cacheKey + ("all", ) cacheRow = self.__cache.get(longCacheKey, validSeconds=self.__validSeconds) if not cacheRow: longCacheKey = cacheKey + (vO, ) cacheRow = self.__cache.get(longCacheKey, validSeconds=self.__validSeconds) if not cacheRow: return S_ERROR( 'Cannot get extended %s (neither for VO = %s nor for "all" Vos)' % (str(cacheKey), vO)) result.update({longCacheKey: cacheRow}) return S_OK(result) # Cache refreshers def refreshCache(self): """ Purges the cache and gets fresh data from the update function. :return: S_OK | S_ERROR. If the first, its content is the new cache. """ self.log.verbose("refreshing...") self.__cache.purgeAll() newCache = self.__updateFunc() if not newCache["OK"]: self.log.error(newCache["Message"]) return newCache newCache = self.__updateCache(newCache["Value"]) self.log.verbose("refreshed") return newCache # Private methods def __updateCache(self, newCache): """ Given the new cache dictionary, updates the internal cache with it. It sets a duration to the entries of <self.__lifeTime> seconds. :Parameters: **newCache** - `dict` dictionary containing a new cache :return: dictionary. It is newCache argument. """ for cacheKey, cacheValue in newCache.items(): self.__cache.add(cacheKey, self.__lifeTime, value=cacheValue) # We are assuming nothing will fail while inserting in the cache. There is # no apparent reason to suspect from that piece of code. return S_OK(newCache)
class DictCache: def __init__(self, deleteFunction=False): """ Initialize the dict cache. If a delete function is specified it will be invoked when deleting a cached object """ self.__lock = LockRing() self.__lock.getLock(self.__class__.__name__, recursive=True) self.__cache = {} self.__deleteFunction = deleteFunction def exists(self, cKey, validSeconds=0): """ Returns True/False if the key exists for the given number of seconds Arguments: - cKey : identification key of the record - validSeconds : The amount of seconds the key has to be valid for """ self.__lock.acquire(self.__class__.__name__) try: #Is the key in the cache? if cKey in self.__cache: expTime = self.__cache[cKey]['expirationTime'] #If it's valid return True! if expTime > datetime.datetime.now() + datetime.timedelta( seconds=validSeconds): return True else: #Delete expired self.delete(cKey) return False finally: self.__lock.release(self.__class__.__name__) def delete(self, cKey): """ Delete a key from the cache Arguments: - cKey : identification key of the record """ self.__lock.acquire(self.__class__.__name__) try: if cKey not in self.__cache: return if self.__deleteFunction: self.__deleteFunction(self.__cache[cKey]['value']) del (self.__cache[cKey]) finally: self.__lock.release(self.__class__.__name__) def add(self, cKey, validSeconds, value=None): """ Add a record to the cache Arguments: - cKey : identification key of the record - validSeconds : valid seconds of this record - value : value of the record """ if max(0, validSeconds) == 0: return self.__lock.acquire(self.__class__.__name__) try: vD = { 'expirationTime': datetime.datetime.now() + datetime.timedelta(seconds=validSeconds), 'value': value } self.__cache[cKey] = vD finally: self.__lock.release(self.__class__.__name__) def get(self, cKey, validSeconds=0): """ Get a record from the cache Arguments: - cKey : identification key of the record - validSeconds : The amount of seconds the key has to be valid for """ self.__lock.acquire(self.__class__.__name__) try: #Is the key in the cache? if cKey in self.__cache: expTime = self.__cache[cKey]['expirationTime'] #If it's valid return True! if expTime > datetime.datetime.now() + datetime.timedelta( seconds=validSeconds): return self.__cache[cKey]['value'] else: #Delete expired self.delete(cKey) return False finally: self.__lock.release(self.__class__.__name__) def showContentsInString(self): """ Return a human readable string to represent the contents """ self.__lock.acquire(self.__class__.__name__) try: data = [] for cKey in self.__cache: data.append("%s:" % str(cKey)) data.append("\tExp: %s" % self.__cache[cKey]['expirationTime']) if self.__cache[cKey]['value']: data.append("\tVal: %s" % self.__cache[cKey]['value']) return "\n".join(data) finally: self.__lock.release(self.__class__.__name__) def getKeys(self, validSeconds=0): """ Get keys for all contents """ self.__lock.acquire(self.__class__.__name__) try: keys = [] limitTime = datetime.datetime.now() + datetime.timedelta( seconds=validSeconds) for cKey in self.__cache: if self.__cache[cKey]['expirationTime'] > limitTime: keys.append(cKey) return keys finally: self.__lock.release(self.__class__.__name__) def purgeExpired(self, expiredInSeconds=0): """ Purge all entries that are expired or will be expired in <expiredInSeconds> """ self.__lock.acquire(self.__class__.__name__) try: keys = [] limitTime = datetime.datetime.now() + datetime.timedelta( seconds=expiredInSeconds) for cKey in self.__cache: if self.__cache[cKey]['expirationTime'] < limitTime: keys.append(cKey) for cKey in keys: if self.__deleteFunction: self.__deleteFunction(self.__cache[cKey]['value']) del (self.__cache[cKey]) finally: self.__lock.release(self.__class__.__name__) def purgeAll(self): """ Purge all entries """ self.__lock.acquire(self.__class__.__name__) try: keys = self.__cache.keys() for cKey in keys: if self.__deleteFunction: self.__deleteFunction(self.__cache[cKey]['value']) del (self.__cache[cKey]) finally: self.__lock.release(self.__class__.__name__)