def _setitem_uid(self, key, value, uid): validKey(key) key_str = key.toString() value_str = value.toxml() tried = [] wasCached = [(key_str, uid) in self._cached] self._cached[(key_str, uid)] = value_str @inlineCallbacks def trySetItem(txn): if tried: yield self._refresh(txn) wasCached[:] = [(key_str, uid) in self._cached] tried.append(True) if wasCached[0]: yield self._updateQuery.on( txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) else: yield self._insertQuery.on( txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) self._cacher.delete(str(self._resourceID)) # Call the registered notification callback if hasattr(self, "_notifyCallback") and self._notifyCallback is not None: self._notifyCallback() def justLogIt(f): f.trap(AllRetriesFailed) self.log_error("setting a property failed; probably nothing.") self._txn.subtransaction(trySetItem).addErrback(justLogIt)
def _delitem_uid(self, key, uid): validKey(key) key_str = key.toString() del self._cached[(key_str, uid)] @inlineCallbacks def doIt(txn): yield self._deleteQuery.on( txn, lambda: KeyError(key), resourceID=self._resourceID, name=key_str, uid=uid ) if self._cacher is not None: self._cacher.delete(self._cacheToken(uid)) # Call the registered notification callback - we need to do this as a preCommit since it involves # a bunch of deferred operations, but this propstore api is not deferred. preCommit will execute # the deferreds properly, and it is fine to wait until everything else is done before sending the # notifications. if hasattr(self, "_notifyCallback") and self._notifyCallback is not None: self._txn.preCommit(self._notifyCallback) def justLogIt(f): f.trap(AllRetriesFailed) self.log.error("setting a property failed; probably nothing.") self._txn.subtransaction(doIt).addErrback(justLogIt)
def _setitem_uid(self, key, value, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.removed: self.removed.remove(effectiveKey) self.modified[effectiveKey] = value
def _setitem_uid(self, key, value, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.removed: self.removed.remove(effectiveKey) self.modified[effectiveKey] = value
def _delitem_uid(self, key, uid): validKey(key) key_str = key.toString() del self._cached[(key_str, uid)] @inlineCallbacks def doIt(txn): yield self._deleteQuery.on(txn, lambda: KeyError(key), resourceID=self._resourceID, name=key_str, uid=uid) if self._cacher is not None: self._cacher.delete(self._cacheToken(uid)) # Call the registered notification callback - we need to do this as a preCommit since it involves # a bunch of deferred operations, but this propstore api is not deferred. preCommit will execute # the deferreds properly, and it is fine to wait until everything else is done before sending the # notifications. if hasattr(self, "_notifyCallback") and self._notifyCallback is not None: self._txn.preCommit(self._notifyCallback) def justLogIt(f): f.trap(AllRetriesFailed) self.log.error("setting a property failed; probably nothing.") self._txn.subtransaction(doIt).addErrback(justLogIt)
def _delitem_uid(self, key, uid): validKey(key) self._txn.execSQL( "delete from RESOURCE_PROPERTY where VIEWER_UID = %s" "and RESOURCE_ID = %s AND NAME = %s", [uid, self._resourceID, key.toString()], raiseOnZeroRowCount=lambda:KeyError(key) )
def _getitem_uid(self, key, uid): validKey(key) try: value = self._cached[(key.toString(), uid)] except KeyError: raise KeyError(key) return WebDAVDocument.fromString(value).root_element
def _getitem_uid(self, key, uid): validKey(key) try: value = self._cached[(key.toString(), uid)] except KeyError: raise KeyError(key) return WebDAVDocument.fromString(value).root_element
def _delitem_uid(self, key, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.modified: del self.modified[effectiveKey] elif self._encodeKey(effectiveKey) not in self.attrs: raise KeyError(key) self.removed.add(effectiveKey)
def _delitem_uid(self, key, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.modified: del self.modified[effectiveKey] elif self._encodeKey(effectiveKey) not in self.attrs: raise KeyError(key) self.removed.add(effectiveKey)
def _delitem_uid(self, key, uid): validKey(key) key_str = key.toString() del self._cached[(key_str, uid)] self._deleteQuery.on(self._txn, lambda:KeyError(key), resourceID=self._resourceID, name=key_str, uid=uid ) self._cacher.delete(str(self._resourceID))
def _getitem_uid(self, key, uid): validKey(key) rows = self._txn.execSQL( "select VALUE from RESOURCE_PROPERTY where " "RESOURCE_ID = %s and NAME = %s and VIEWER_UID = %s", [self._resourceID, key.toString(), uid] ) if not rows: raise KeyError(key) return WebDAVDocument.fromString(rows[0][0]).root_element
def _setitem_uid(self, key, value, uid): validKey(key) try: self._delitem_uid(key, uid) except KeyError: pass self._txn.execSQL( "insert into RESOURCE_PROPERTY " "(RESOURCE_ID, NAME, VALUE, VIEWER_UID) values (%s, %s, %s, %s)", [self._resourceID, key.toString(), value.toxml(), uid] )
def _setitem_uid(self, key, value, uid): validKey(key) key_str = key.toString() value_str = value.toxml() tried = [] wasCached = [(key_str, uid) in self._cached] self._cached[(key_str, uid)] = value_str @inlineCallbacks def trySetItem(txn): if tried: yield self._refresh(txn) wasCached[:] = [(key_str, uid) in self._cached] tried.append(True) if wasCached[0]: yield self._updateQuery.on(txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) else: yield self._insertQuery.on(txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) if self._cacher is not None: self._cacher.delete(self._cacheToken(uid)) # Call the registered notification callback - we need to do this as a preCommit since it involves # a bunch of deferred operations, but this propstore api is not deferred. preCommit will execute # the deferreds properly, and it is fine to wait until everything else is done before sending the # notifications. if hasattr(self, "_notifyCallback") and self._notifyCallback is not None: self._txn.preCommit(self._notifyCallback) def justLogIt(f): f.trap(AllRetriesFailed) self.log.error("setting a property failed; probably nothing.") self._txn.subtransaction(trySetItem).addErrback(justLogIt)
def _getitem_uid(self, key, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.modified: return self.modified[effectiveKey] if effectiveKey in self.removed: raise KeyError(key) try: try: data = self.attrs[self._encodeKey(effectiveKey)] except IOError, e: if e.errno in [_ERRNO_NO_ATTR, errno.ENOENT]: raise KeyError(key) raise PropertyStoreError(e) except KeyError: # Check for uncompressed namespace if effectiveKey[0].namespace in self._namespaceCompress: try: data = self.attrs[self._encodeKey(effectiveKey, compressNamespace=False)] except IOError, e: raise KeyError(key) try: # Write it back using the compressed format self.attrs[self._encodeKey(effectiveKey)] = data del self.attrs[self._encodeKey(effectiveKey, compressNamespace=False)] except IOError, e: msg = ( "Unable to upgrade property " "to compressed namespace: %s" % (key.toString()) ) self.log.error(msg) raise PropertyStoreError(msg)
def _getitem_uid(self, key, uid): validKey(key) effectiveKey = (key, uid) if effectiveKey in self.modified: return self.modified[effectiveKey] if effectiveKey in self.removed: raise KeyError(key) try: try: data = self.attrs[self._encodeKey(effectiveKey)] except IOError, e: if e.errno in [_ERRNO_NO_ATTR, errno.ENOENT]: raise KeyError(key) raise PropertyStoreError(e) except KeyError: # Check for uncompressed namespace if effectiveKey[0].namespace in self._namespaceCompress: try: data = self.attrs[self._encodeKey(effectiveKey, compressNamespace=False)] except IOError, e: raise KeyError(key) try: # Write it back using the compressed format self.attrs[self._encodeKey(effectiveKey)] = data del self.attrs[self._encodeKey(effectiveKey, compressNamespace=False)] except IOError, e: msg = ( "Unable to upgrade property " "to compressed namespace: %s" % (key.toString()) ) self.log.error(msg) raise PropertyStoreError(msg)
def _setitem_uid(self, key, value, uid): validKey(key) key_str = key.toString() value_str = value.toxml() tried = [] wasCached = [(key_str, uid) in self._cached] self._cached[(key_str, uid)] = value_str @inlineCallbacks def trySetItem(txn): if tried: yield self._refresh(txn) wasCached[:] = [(key_str, uid) in self._cached] tried.append(True) if wasCached[0]: yield self._updateQuery.on( txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) else: yield self._insertQuery.on( txn, resourceID=self._resourceID, value=value_str, name=key_str, uid=uid) if self._cacher is not None: self._cacher.delete(self._cacheToken(uid)) # Call the registered notification callback - we need to do this as a preCommit since it involves # a bunch of deferred operations, but this propstore api is not deferred. preCommit will execute # the deferreds properly, and it is fine to wait until everything else is done before sending the # notifications. if hasattr(self, "_notifyCallback") and self._notifyCallback is not None: self._txn.preCommit(self._notifyCallback) def justLogIt(f): f.trap(AllRetriesFailed) self.log.error("setting a property failed; probably nothing.") self._txn.subtransaction(trySetItem).addErrback(justLogIt)
def __setitem__(self, key, value): validKey(key) raise PropertyChangeNotAllowedError("Property store is read-only.", (key,))
def __delitem__(self, key): validKey(key) raise KeyError(key)
def __setitem__(self, key, value): validKey(key) raise PropertyChangeNotAllowedError("Property store is read-only.", (key,))
def __delitem__(self, key): validKey(key) raise KeyError(key)