def get(self, token): """Return a lock dictionary for a token. If the lock does not exist or is expired, None is returned. token: lock token Returns: Lock dictionary or <None> Side effect: if lock is expired, it will be purged and None is returned. """ self._lock.acquireRead() try: lock_base = self._session.query(Lock).filter(Lock.token == token).one_or_none() if lock_base is None: # Lock not found: purge dangling URL2TOKEN entries _logger.debug("Lock purged dangling: %s" % token) self.delete(token) return None expire = float(lock_base.expire) if 0 <= expire < time.time(): _logger.debug("Lock timed-out(%s): %s" % (expire, lockString(from_base_to_dict(lock_base)))) self.delete(token) return None return from_base_to_dict(lock_base) finally: self._lock.release()
def delete(self, token): """Delete lock. Returns True on success. False, if token does not exist, or is expired. """ self._lock.acquireWrite() try: lock_db = self._session.query(Lock).filter( Lock.token == token).one_or_none() _logger.debug("delete %s" % lockString(from_base_to_dict(lock_db))) if lock_db is None: return False # Remove url to lock mapping url2token = self._session.query(Url2Token).filter( Url2Token.path == lock_db.root, Url2Token.token == token).one_or_none() if url2token is not None: self._session.delete(url2token) # Remove the lock self._session.delete(lock_db) self._session.commit() self._flush() finally: self._lock.release() return True
def delete(self, token): """Delete lock. Returns True on success. False, if token does not exist, or is expired. """ self._lock.acquireWrite() try: lock_db = self._session.query(Lock).filter(Lock.token == token).one_or_none() _logger.debug("delete %s" % lockString(from_base_to_dict(lock_db))) if lock_db is None: return False # Remove url to lock mapping url2token = self._session.query(Url2Token).filter( Url2Token.path == lock_db.root, Url2Token.token == token).one_or_none() if url2token is not None: self._session.delete(url2token) # Remove the lock self._session.delete(lock_db) self._session.commit() self._flush() finally: self._lock.release() return True
def get(self, token): """Return a lock dictionary for a token. If the lock does not exist or is expired, None is returned. token: lock token Returns: Lock dictionary or <None> Side effect: if lock is expired, it will be purged and None is returned. """ self._lock.acquireRead() try: lock_base = self._session.query(Lock).filter( Lock.token == token).one_or_none() if lock_base is None: # Lock not found: purge dangling URL2TOKEN entries _logger.debug("Lock purged dangling: %s" % token) self.delete(token) return None expire = float(lock_base.expire) if 0 <= expire < time.time(): _logger.debug( "Lock timed-out(%s): %s" % (expire, lockString(from_base_to_dict(lock_base)))) self.delete(token) return None return from_base_to_dict(lock_base) finally: self._lock.release()
def delete(self, token): """Delete lock. Returns True on success. False, if token does not exist, or is expired. """ self._lock.acquireWrite() try: lock = self._dict.get(token) _logger.debug("delete %s" % lockString(lock)) if lock is None: return False # Remove url to lock mapping key = "URL2TOKEN:%s" % lock.get("root") if key in self._dict: # _logger.debug(" delete token %s from url %s" % (token, lock.get("root"))) tokList = self._dict[key] if len(tokList) > 1: # Note: shelve dictionary returns copies, so we must reassign values: tokList.remove(token) self._dict[key] = tokList else: del self._dict[key] # Remove the lock del self._dict[token] self._flush() finally: self._lock.release() return True
def get(self, token): """Return a lock dictionary for a token. If the lock does not exist or is expired, None is returned. token: lock token Returns: Lock dictionary or <None> Side effect: if lock is expired, it will be purged and None is returned. """ self._lock.acquireRead() try: lock = self._dict.get(token) if lock is None: # Lock not found: purge dangling URL2TOKEN entries _logger.debug("Lock purged dangling: %s" % token) self.delete(token) return None expire = float(lock["expire"]) if expire >= 0 and expire < time.time(): _logger.debug("Lock timed-out(%s): %s" % (expire, lockString(lock))) self.delete(token) return None return lock finally: self._lock.release()
def create(self, path, lock): """Create a direct lock for a resource path. path: Normalized path (utf8 encoded string, no trailing '/') lock: lock dictionary, without a token entry Returns: New unique lock token.: <lock **Note:** the lock dictionary may be modified on return: - lock['root'] is ignored and set to the normalized <path> - lock['timeout'] may be normalized and shorter than requested - lock['token'] is added """ self._lock.acquireWrite() try: # We expect only a lock definition, not an existing lock assert lock.get("token") is None assert lock.get("expire") is None, "Use timeout instead of expire" assert path and "/" in path # Normalize root: /foo/bar org_path = path path = normalizeLockRoot(path) lock["root"] = path # Normalize timeout from ttl to expire-date timeout = float(lock.get("timeout")) if timeout is None: timeout = LockStorage.LOCK_TIME_OUT_DEFAULT elif timeout < 0 or timeout > LockStorage.LOCK_TIME_OUT_MAX: timeout = LockStorage.LOCK_TIME_OUT_MAX lock["timeout"] = timeout lock["expire"] = time.time() + timeout validateLock(lock) token = generateLockToken() lock["token"] = token # Store lock lock_db = from_dict_to_base(lock) self._session.add(lock_db) # Store locked path reference url2token = Url2Token( path=path, token=token ) self._session.add(url2token) self._session.commit() self._flush() _logger.debug("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) # print("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) return lock finally: self._lock.release()
def create(self, path, lock): """Create a direct lock for a resource path. path: Normalized path (utf8 encoded string, no trailing '/') lock: lock dictionary, without a token entry Returns: New unique lock token.: <lock **Note:** the lock dictionary may be modified on return: - lock['root'] is ignored and set to the normalized <path> - lock['timeout'] may be normalized and shorter than requested - lock['token'] is added """ self._lock.acquireWrite() try: # We expect only a lock definition, not an existing lock assert lock.get("token") is None assert lock.get("expire") is None, "Use timeout instead of expire" assert path and "/" in path # Normalize root: /foo/bar org_path = path path = normalizeLockRoot(path) lock["root"] = path # Normalize timeout from ttl to expire-date timeout = float(lock.get("timeout")) if timeout is None: timeout = LockStorage.LOCK_TIME_OUT_DEFAULT elif timeout < 0 or timeout > LockStorage.LOCK_TIME_OUT_MAX: timeout = LockStorage.LOCK_TIME_OUT_MAX lock["timeout"] = timeout lock["expire"] = time.time() + timeout validateLock(lock) token = generateLockToken() lock["token"] = token # Store lock lock_db = from_dict_to_base(lock) self._session.add(lock_db) # Store locked path reference url2token = Url2Token(path=path, token=token) self._session.add(url2token) self._session.commit() self._flush() _logger.debug("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) # print("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) return lock finally: self._lock.release()
def create(self, path, lock): """Create a direct lock for a resource path. path: Normalized path (utf8 encoded string, no trailing '/') lock: lock dictionary, without a token entry Returns: New unique lock token.: <lock **Note:** the lock dictionary may be modified on return: - lock['root'] is ignored and set to the normalized <path> - lock['timeout'] may be normalized and shorter than requested - lock['token'] is added """ self._lock.acquireWrite() try: # We expect only a lock definition, not an existing lock assert lock.get("token") is None assert lock.get("expire") is None, "Use timeout instead of expire" assert path and "/" in path # Normalize root: /foo/bar org_path = path path = normalizeLockRoot(path) lock["root"] = path # Normalize timeout from ttl to expire-date timeout = float(lock.get("timeout")) if timeout is None: timeout = LockStorageDict.LOCK_TIME_OUT_DEFAULT elif timeout < 0 or timeout > LockStorageDict.LOCK_TIME_OUT_MAX: timeout = LockStorageDict.LOCK_TIME_OUT_MAX lock["timeout"] = timeout lock["expire"] = time.time() + timeout validateLock(lock) token = generateLockToken() lock["token"] = token # Store lock self._dict[token] = lock # Store locked path reference key = "URL2TOKEN:%s" % path if not key in self._dict: self._dict[key] = [token] else: # Note: Shelve dictionary returns copies, so we must reassign values: tokList = self._dict[key] tokList.append(token) self._dict[key] = tokList self._flush() _logger.debug("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) # print("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) return lock finally: self._lock.release()
def create(self, path, lock): """Create a direct lock for a resource path. path: Normalized path (utf8 encoded string, no trailing '/') lock: lock dictionary, without a token entry Returns: New unique lock token.: <lock **Note:** the lock dictionary may be modified on return: - lock['root'] is ignored and set to the normalized <path> - lock['timeout'] may be normalized and shorter than requested - lock['token'] is added """ self._lock.acquireWrite() try: # We expect only a lock definition, not an existing lock assert lock.get("token") is None assert lock.get("expire") is None, "Use timeout instead of expire" assert path and "/" in path # Normalize root: /foo/bar org_path = path path = normalizeLockRoot(path) lock["root"] = path # Normalize timeout from ttl to expire-date timeout = float(lock.get("timeout")) if timeout is None: timeout = LockStorageDict.LOCK_TIME_OUT_DEFAULT elif timeout < 0 or timeout > LockStorageDict.LOCK_TIME_OUT_MAX: timeout = LockStorageDict.LOCK_TIME_OUT_MAX lock["timeout"] = timeout lock["expire"] = time.time() + timeout validateLock(lock) token = generateLockToken() lock["token"] = token # Store lock self._dict[token] = lock # Store locked path reference key = "URL2TOKEN:%s" % path if not key in self._dict: self._dict[key] = [ token ] else: # Note: Shelve dictionary returns copies, so we must reassign values: tokList = self._dict[key] tokList.append(token) self._dict[key] = tokList self._flush() _logger.debug("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) # print("LockStorageDict.set(%r): %s" % (org_path, lockString(lock))) return lock finally: self._lock.release()