def refEnd(self, attrs): uuid = UUID(self.data) name = attrs['name'] generator = self.generator if 'first' in attrs: first = True alias = {} for ref in self.store.loadRefs(self.version, self.uuid, uuid, UUID(attrs['first'])): if first: first = False attrs['uuid'] = self.data generator.startElement('ref', attrs) if ref[4] is not None: alias['alias'] = ref[4] generator.startElement('ref', alias) else: generator.startElement('ref', None) generator.characters(ref[0].str64()) generator.endElement('ref') if not first: generator.endElement('ref') else: generator.startElement('ref', attrs) generator.characters(self.data) generator.endElement('ref')
def applyHistory(self, fn, oldVersion, newVersion): store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor(self._versions) try: value = cursor.set_range(pack('>l', oldVersion + 1), self._flags) except DBNotFoundError: return except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(18) continue else: raise try: while value is not None: version, uuid = unpack('>l16s', value[0]) if version > newVersion: break value = value[1] status, parentId = unpack('>l16s', value[16:36]) if status & Item.DELETED: dirties = HashTuple() else: pos = -(unpack('>l', value[-4:])[0] + 2) << 2 value = value[pos:-8] dirties = unpack('>%dl' %(len(value) >> 2), value) dirties = HashTuple(dirties) fn(UUID(uuid), version, status, UUID(parentId), dirties) value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(19) continue else: raise return finally: self.closeCursor(cursor, self._versions) store.abortTransaction(txnStatus)
def refEnd(self, attrs): uuid = UUID(self.data) name = attrs['name'] generator = self.generator if self.cloud is not None: endpoints = self.cloud.getAttributeEndpoints(name) else: endpoints = None def processRef(ref): output = True if endpoints: for endpoint in endpoints: policy = endpoint.includePolicy length = len(endpoint.attribute) if length == 1 and policy == 'none': output = False elif length > 1 or policy != 'byRef': eps = self.endpoints.get(ref[0], None) if eps is not None: eps.append(endpoint) else: self.endpoints[ref[0]] = [ endpoint ] return output if 'first' in attrs: first = True alias = {} for ref in self.store.loadRefs(self.version, self.uuid, uuid, UUID(attrs['first'])): if processRef(ref): if first: first = False attrs['uuid'] = self.data generator.startElement('ref', attrs) if ref[4] is not None: alias['alias'] = ref[4] generator.startElement('ref', alias) else: generator.startElement('ref', None) generator.characters(ref[0].str64()) generator.endElement('ref') if not first: generator.endElement('ref') elif processRef((uuid, uuid, None, None, None)): generator.startElement('ref', attrs) generator.characters(self.data) generator.endElement('ref')
def refEnd(self, attrs): if attrs['name'] == self.name: uuid = UUID(self.data) if 'first' in attrs: store = self.repository.repository.store first = UUID(attrs['first']) self.values = [ ref[0] for ref in store.loadRefs(self.version, self.uuid, uuid, first) ] else: self.values = [ uuid ]
def applyHistory(self, fn, uuid, oldVersion, newVersion): store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor(self._history) try: value = cursor.set_range(pack('>16sl', uuid._uuid, oldVersion + 1), self._flags) except DBNotFoundError: return except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(16) continue else: raise try: while value is not None: uCol, version, uRef = unpack('>16sl16s', value[0]) if version > newVersion or uCol != uuid._uuid: break fn(version, (UUID(uCol), UUID(uRef)), self._readRef(value[1])) value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(17) continue else: raise return finally: self.closeCursor(cursor, self._history) store.abortTransaction(txnStatus)
def getTypeName(self, attribute, attrs, default): name = None if attrs.has_key('typeid'): try: name = self.repository[UUID(attrs['typeid'])].handlerName() except KeyError: raise TypeError, "Type %s not found" % (attrs['typeid']) elif attrs.has_key('typepath'): typeItem = self.repository.find(Path(attrs['typepath'])) if typeItem is None: raise TypeError, "Type %s not found" % (attrs['typepath']) name = typeItem.handlerName() elif attrs.has_key('type'): name = attrs['type'] elif attribute is not None: attrType = attribute.getAspect('type', None) if attrType is not None: name = attrType.handlerName() return name or default
def _call_(self, method, *args): iq = jabber.Iq(to=self.iqTo, type='get') iq.setQuery('jabber:iq:rpc') iq.setID(UUID().str64()) iq.setQueryPayload(xmlrpclib.dumps(args, method)) self.send(iq) response = self.waitForResponse(iq.getID()) if response is None: raise ValueError, self.lastErr xml = response.getQueryPayload() if xml.name == 'value': return "".join(xml.data) if xml.name == 'values': return tuple(["".join(kid.data) for kid in xml.kids]) if xml.name == 'none': return None if xml.name == 'error': raise RemoteError, "".join(xml.data) return xml
def getItemParentId(self, version, uuid): version, item = self._findItem(version, uuid) if item is not None: return UUID(item[20:36]) return None
def readValue(self, itemReader, offset, data, withSchema, view, name, afterLoadHooks): if data[offset] == '\0': return offset+1, None return offset+17, SingleRef(UUID(data[offset+1:offset+17]))
def decode(self, returnType, offset, value): if value is None: return None c = returnType[offset] if c == 'x': return value.decode('base64').decode('zlib') if c == 'u': if value == 'None': return None return UUID(value) if c == 's': return value if c == 'i': return long(value) if c == 't': values = [] for i in xrange(len(value)): values.append(self.decode(returnType, i + 1, value[i])) return tuple(values) raise TypeError, '%s: unsupported signature char' %(c)
def itemStart(self, attrs): parent = None if attrs.get('afterLoadHooks', 'False') == 'True': self.hooks.append([]) if attrs.has_key('path'): parent = self.view.find(Path(attrs['path'])) elif attrs.has_key('uuid'): parent = self.view.find(UUID(attrs['uuid'])) elif attrs.has_key('file'): parent = self.loadItem(os.path.join(self.cwd[-1], attrs['file']), self.parent[-1]) elif attrs.has_key('files'): pattern = '^' + attrs['files'] + '$' pattern = pattern.replace('.', '\\.').replace('*', '.*') exp = re.compile(pattern) for file in os.listdir(self.cwd[-1]): if exp.match(file): parent = self.loadItem(os.path.join(self.cwd[-1], file), self.parent[-1]) if self.errorOccurred(): return self.parent.append(parent) if attrs.has_key('cwd'): self.cwd.append(os.path.join(self.cwd[-1], attrs['cwd']))
def _readValue(self, value, offset): code = value[offset] offset += 1 if code == '\0': return (1, None) if code == '\1': return (1, True) if code == '\2': return (1, False) if code == '\3': return (17, UUID(value[offset:offset+16])) if code == '\4': return (5, unpack('>l', value[offset:offset+4])[0]) if code == '\5': l, = unpack('>H', value[offset:offset+2]) offset += 2 return (l + 3, value[offset:offset+l]) raise ValueError, code
def kindEnd(self, itemHandler, attrs): if attrs['type'] == 'uuid': self.kindRef = UUID(self.data) else: self.kindRef = Path(self.data) self.kind = self.repository._findSchema(self.kindRef, self.withSchema)
def itemsStart(self, attrs): if attrs is not None and 'versionId' in attrs: versionId = UUID(attrs['versionId']) if versionId != self.versionId: raise ValueError, "remote version ids don't match" self._txnStatus = self.store.startTransaction() self._lock = self.store.acquireLock()
def readName(self, version, key, name): if name is None: raise ValueError, 'name is None' if isinstance(name, unicode): name = name.encode('utf-8') cursorKey = pack('>16sl', key._uuid, _hash(name)) store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor() try: value = cursor.set_range(cursorKey, self._flags) except DBNotFoundError: return None except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(8) continue else: raise try: while value is not None and value[0].startswith(cursorKey): nameVer = ~unpack('>l', value[0][-4:])[0] if nameVer <= version: if value[1] == value[0][0:16]: # deleted name return None return UUID(value[1]) else: value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(9) continue else: raise return None finally: self.closeCursor(cursor) store.abortTransaction(txnStatus)
class RemoteStore(XMLStore): def __init__(self, repository, transport): super(RemoteStore, self).__init__(repository) self.transport = transport def open(self, **kwds): super(RemoteStore, self).open(**kwds) self.transport.open() def close(self): super(RemoteStore, self).close() self.transport.close() def loadItem(self, version, uuid): doc = super(RemoteStore, self).loadItem(version, uuid) if doc is None: v, versionId = self._values.getVersionInfo(self.itsUUID) remoteVersion = self._values.getVersion(versionId) xml = self.transport.serveItem(remoteVersion, uuid, self.repository.cloudAlias) if xml is not None: filter = RemoteFilter(self, versionId) self.transport.parseDoc(xml, filter) doc = filter.getDocument() return doc def getVersion(self): version = super(RemoteStore, self).getVersion() values = self._values if version == 0: versionId, version = self.transport.getVersionInfo() txnStatus = 0 try: txnStatus = self.startTransaction() values.setVersion(version) values.setVersion(version, versionId) values.setVersionId(versionId, self.itsUUID) except: self.abortTransaction(txnStatus) raise else: self.commitTransaction(txnStatus) return version itsUUID = UUID('200a5564-a60f-11d8-fb65-000393db837c')
def kindEnd(self, attrs): assert attrs['type'] == 'uuid' kind = self.repository.find(UUID(self.data)) if self.cloud is None: clouds = kind.getClouds(self.cloudAlias) if clouds: self.cloud = clouds.first() elif not kind.isKindOf(self.cloud.kind): raise TypeError, '%s is not a kind this cloud (%s) understands' %(kind.itsPath, self.cloud.itsPath)
def parentEnd(self, itemHandler, attrs): if attrs['type'] == 'uuid': self.parentRef = UUID(self.data) else: self.parentRef = Path(self.data) self.isContainer = attrs.get('container', 'False') == 'True' self.parent = self.repository.find(self.parentRef) if self.parent is None: self.afterLoadHooks.append(self._move)
def setVersion(self, version, uuid=None): if uuid is None: uuid = Repository.itsUUID if version != 0: versionId, x, format, schema = self.getVersionInfo(uuid) else: versionId, format, schema = UUID(), ValueContainer.FORMAT_VERSION, RepositoryView.CORE_SCHEMA_VERSION self.put(uuid._uuid, pack('>16slll', versionId._uuid, version, format, schema))
def exists(self): value = self._container.get(self._key) if value is None: return False zero, self.length, timeHi, timeLo, uuid = unpack('>LLLL16s', value) self.timeModified = timeHi << 32L | timeLo self._uuid = UUID(uuid) return True
def _type(self, offset, data, attrType, view, name): if ord(data[offset]) & DBItemWriter.TYPED: typeId = UUID(data[offset + 1:offset + 17]) attrType = view.find(typeId) if attrType is None: raise LoadValueError, (self.name or self.uItem, name, "type not found: %s" % (typeId)) return offset + 17, attrType return offset + 1, attrType
def kindQuery(self, version, uuid, fn): store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor(self._index) try: value = cursor.set_range(uuid._uuid, self._flags) except DBNotFoundError: return except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(22) continue else: raise try: lastItem = None while value is not None: uKind, uItem, vItem = unpack('>16s16sl', value[0]) if uKind != uuid._uuid: break vItem = ~vItem if vItem <= version and uItem != lastItem: args = self._readItem(vItem, value[1]) if not fn(UUID(uItem), *args): break else: lastItem = uItem value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(23) continue else: raise return finally: self.closeCursor(cursor, self._index) store.abortTransaction(txnStatus)
def _readItem(self, itemVer, value): uKind = UUID(value[0:16]) status, = unpack('>l', value[16:20]) uParent = UUID(value[20:36]) offset = 36 l, name = self._readValue(value, offset) offset += l l, moduleName = self._readValue(value, offset) offset += l l, className = self._readValue(value, offset) offset += l count, = unpack('>l', value[-8:-4]) values = [] for i in xrange(count): values.append(UUID(value[offset+4:offset+20])) offset += 20 return (itemVer, uKind, status, uParent, name, moduleName, className, values)
def getVersionInfo(self, uuid): value = self.get(uuid._uuid) if value is None: return None if len(value) == 24: # pre 0.5.3 versionId, version, format = unpack('>16sll', value) schema = 0 else: versionId, version, format, schema = unpack('>16slll', value) return UUID(versionId), version, format, schema
def readNames(self, version, key): results = [] cursorKey = key._uuid store = self.store while True: txnStatus = 0 cursor = None try: txnStatus = store.startTransaction() cursor = self.openCursor() try: value = cursor.set_range(cursorKey, self._flags) except DBNotFoundError: return results except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(12) continue else: raise currentHash = None try: while value is not None and value[0].startswith(cursorKey): nameHash, nameVer = unpack('>ll', value[0][-8:]) if nameHash != currentHash and ~nameVer <= version: currentHash = nameHash if value[1] != value[0][0:16]: # !deleted name results.append(UUID(value[1])) value = cursor.next() except DBLockDeadlockError: if txnStatus & store.TXNSTARTED: self._logDL(13) continue else: raise return results finally: self.closeCursor(cursor) store.abortTransaction(txnStatus)
def refEnd(self, itemHandler, attrs): if self.tags[-1] == 'item': attribute = self.attributes.pop() cardinality = self.getCardinality(attribute, attrs) otherCard = attrs.get('otherCard', None) else: cardinality = 'single' otherCard = self.tagAttrs[-1].get('otherCard', None) if cardinality == 'single': # cardinality of tag typeName = attrs.get('type', 'path') if typeName == 'path': ref = Path(self.data) elif typeName == 'none': self.references[attrs['name']] = None return else: ref = UUID(self.data) if self.collections: refList = self.collections[-1] self.refs.append( RefArgs(refList._name, None, refList._otherName, ref, otherCard=otherCard, otherAlias=attrs.get('otherAlias'), previous=self.refName(attrs, 'previous'), next=self.refName(attrs, 'next'), alias=attrs.get('alias'))) else: name = attrs['name'] otherName = self.getOtherName(name, self.getAttribute(name), attrs) self.refs.append( RefArgs(name, None, otherName, ref, otherCard=otherCard, otherAlias=attrs.get('otherAlias'))) else: value = self.collections.pop() self.references[attrs['name']] = value if value._indexes: self.afterLoadHooks.append(value._restoreIndexes)
def refStart(self, attrs): if self._isSkipping: return if attrs and 'first' in attrs: self._isOn = False self._refsUUID = UUID(attrs['uuid']) self._keyBuffer = self.store._refs.prepareKey( self.itemUUID, self._refsUUID) self._ref = None self._previous = None self._alias = None
def _find(spec): typeAttr = attrs.get('type', 'path') if typeAttr == 'path': item = self.parent.find(Path(spec)) elif typeAttr == 'uuid': item = self.parent.find(UUID(spec)) else: raise TypeError, typeAttr if item is None: raise NoSuchItemError, (spec, self.version) return item
def append(self, name): """ Add a name to this path. C{name} should be a string without C{/} characters. @param name: the name to add @type name: a string """ if not isinstance(name, UUID) and name.startswith('{'): name = UUID(name[1:-1]) self._names.append(name)
def itemStart(self, itemHandler, attrs): super(ItemHandler, self).itemStart(itemHandler, attrs) if self.values is None: self.values = Values(None) if self.references is None: self.references = References(None) self.refs = [] self.name = None self.cls = None self.parentRef = None self.isContainer = False self.uuid = UUID(attrs.get('uuid')) self.version = int(attrs.get('version', '0')) self.update = update = attrs.get('update') self.delete = delete = attrs.get('delete') def _find(spec): typeAttr = attrs.get('type', 'path') if typeAttr == 'path': item = self.parent.find(Path(spec)) elif typeAttr == 'uuid': item = self.parent.find(UUID(spec)) else: raise TypeError, typeAttr if item is None: raise NoSuchItemError, (spec, self.version) return item if update is not None: item = _find(update) elif delete is not None: item = _find(delete) else: item = None if item is not None: self.item = item self.cls = type(item) self.version = item._version self.name = item.itsName self.kind = item.itsKind self.uuid = item.itsUUID self.parent = item.itsParent