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
