def test_sync_merge(self):
(doc, rev1, rev2) = self.createMerge(
"org.peerdrive.folder",
{"META": struct.dumps({"a": 1}), "PDSD": struct.dumps([{"": 1}, {"": 2}])},
{"META": struct.dumps({"a": 4, "b": 2}), "PDSD": struct.dumps([{"": 1}, {"": 2}, {"": 3}])},
{"META": struct.dumps({"a": 1, "c": 3}), "PDSD": struct.dumps([{"": 2}])},
)
l = self.performSync(doc, "merge")
rev = l.revs()[0]
s = Connector().stat(rev)
self.assertEqual(len(s.parents()), 2)
self.assertTrue(rev1 in s.parents())
self.assertTrue(rev2 in s.parents())
# all revs on all stores?
l = Connector().lookupRev(rev1)
self.assertTrue(self.store1 in l)
self.assertTrue(self.store2 in l)
l = Connector().lookupRev(rev2)
self.assertTrue(self.store1 in l)
self.assertTrue(self.store2 in l)
# see if merge was ok
with Connector().peek(self.store1, rev) as r:
meta = struct.loads(self.store1, r.readAll("META"))
if "org.peerdrive.annotation" in meta:
del meta["org.peerdrive.annotation"]
self.assertEqual(meta, {"a": 4, "b": 2, "c": 3})
pdsd = sorted(struct.loads(self.store1, r.readAll("PDSD")))
self.assertEqual(pdsd, [{"": 2}, {"": 3}])
def docMergePerform(self, writer, baseReader, mergeReaders, changedParts):
conflicts = super(FolderWidget, self).docMergePerform(writer, baseReader, mergeReaders, changedParts)
if 'PDSD' in changedParts:
basePdsd = struct.loads(self.store(), baseReader.readAll('PDSD'))
mergePdsd = []
for r in mergeReaders:
mergePdsd.append(struct.loads(self.store(), r.readAll('PDSD')))
(newPdsd, newConflict) = struct.merge(basePdsd, mergePdsd)
conflicts = conflicts or newConflict
writer.writeAll('PDSD', struct.dumps(newPdsd))
return conflicts
def docMergePerform(self, writer, baseReader, mergeReaders, changedParts):
conflicts = super(FolderWidget,
self).docMergePerform(writer, baseReader,
mergeReaders, changedParts)
if 'PDSD' in changedParts:
basePdsd = struct.loads(self.store(), baseReader.readAll('PDSD'))
mergePdsd = []
for r in mergeReaders:
mergePdsd.append(struct.loads(self.store(), r.readAll('PDSD')))
(newPdsd, newConflict) = struct.merge(basePdsd, mergePdsd)
conflicts = conflicts or newConflict
writer.writeAll('PDSD', struct.dumps(newPdsd))
return conflicts
def __updateColumns(self):
# This makes only sense if we're a valid entry
if not self.__valid:
return
try:
stat = Connector().stat(self.__rev)
with Connector().peek(self.__store, self.__rev) as r:
try:
metaData = struct.loads(self.__store, r.readAll('META'))
except:
metaData = { }
for i in xrange(len(self.__columnDefs)):
column = self.__columnDefs[i]
if column.derived():
self.__columnValues[i] = column.extract(stat, metaData)
self.__metaData = metaData
except IOError:
self.__metaData = None
for i in xrange(len(self.__columnDefs)):
column = self.__columnDefs[i]
if column.derived():
self.__columnValues[i] = column.default()
def load(self, store, rev):
title = ""
description = ""
tags = []
try:
with Connector().peek(store, rev) as r:
metaData = struct.loads(store, r.readAll('META'))
title = extractMetaData(
metaData,
["org.peerdrive.annotation", "title"],
"")
description = extractMetaData(
metaData,
["org.peerdrive.annotation", "description"],
"")
tags = extractMetaData(
metaData,
["org.peerdrive.annotation", "tags"],
[])
except IOError:
pass
tags.sort()
self.__titleEdit.setText(title)
self.__descEdit.setText(description)
if tags:
self.__tagsEdit.setText(reduce(lambda x, y: x+", "+y, tags))
else:
self.__tagsEdit.setText("")
def __init__(self):
self.sysStore = Connector().enum().sysStore()
self.syncDoc = struct.Folder(struct.DocLink(self.sysStore, self.sysStore))["syncrules"].doc()
self.syncRev = Connector().lookupDoc(self.syncDoc).rev(self.sysStore)
with Connector().peek(self.sysStore, self.syncRev) as r:
rules = struct.loads(self.sysStore, r.readAll('PDSD'))
self.__changed = False
self.__rules = {}
for rule in rules:
self.__rules[(rule['from'].decode('hex'), rule['to'].decode('hex'))] = rule
def test_sync_merge(self):
(doc, rev1, rev2) = self.createMerge("org.peerdrive.folder",
{
'META':struct.dumps({"a":1}),
'PDSD':struct.dumps([{'':1}, {'':2}])
},
{
'META':struct.dumps({"a":4, "b":2}),
'PDSD':struct.dumps([{'':1}, {'':2}, {'':3}])
},
{
'META':struct.dumps({"a":1, "c":3}),
'PDSD':struct.dumps([{'':2}])
})
l = self.performSync(doc, 'merge')
rev = l.revs()[0]
s = Connector().stat(rev)
self.assertEqual(len(s.parents()), 2)
self.assertTrue(rev1 in s.parents())
self.assertTrue(rev2 in s.parents())
# all revs on all stores?
l = Connector().lookupRev(rev1)
self.assertTrue(self.store1 in l)
self.assertTrue(self.store2 in l)
l = Connector().lookupRev(rev2)
self.assertTrue(self.store1 in l)
self.assertTrue(self.store2 in l)
# see if merge was ok
with Connector().peek(self.store1, rev) as r:
meta = struct.loads(self.store1, r.readAll('META'))
if 'org.peerdrive.annotation' in meta:
del meta['org.peerdrive.annotation']
self.assertEqual(meta, {"a":4, "b":2, "c":3})
pdsd = sorted(struct.loads(self.store1, r.readAll('PDSD')))
self.assertEqual(pdsd, [{'':2},{'':3}])
def __loadComment(self, rev):
stat = Connector().stat(rev, [self.__store])
mtime = str(stat.mtime())
comment = ""
if 'META' in stat.parts():
try:
with Connector().peek(self.__store, rev) as r:
metaData = struct.loads(self.__store, r.readAll('META'))
comment = extractMetaData(
metaData,
["org.peerdrive.annotation", "comment"],
"")
except IOError:
pass
return mtime + " - " + comment
def doLoad(self, handle, readWrite, autoClean):
self.__mutable = readWrite
self.__changedContent = False
self.__autoClean = autoClean
self.__typeCodes = set()
self.__store = handle.getStore()
self._listing = []
data = struct.loads(handle.getStore(), handle.readAll('PDSD'))
listing = [ FolderEntry(item, self, self._columns) for item in data ]
for entry in listing:
if entry.isValid() or (not self.__autoClean):
self.__typeCodes.add(entry.getTypeCode())
self._listing.append(entry)
Connector().watch(entry)
else:
self.__changedContent = True
self.reset()
def __save(self):
self.__buttonBox.button(QtGui.QDialogButtonBox.Save).setEnabled(False)
with Connector().peek(self.__store, self.__rev) as r:
metaData = struct.loads(self.__store, r.readAll('META'))
setMetaData(metaData, ["org.peerdrive.annotation", "title"],
self.__annoTab.getTitle())
setMetaData(metaData, ["org.peerdrive.annotation", "description"],
self.__annoTab.getDescription())
tagString = self.__annoTab.getTags()
if tagString is not None:
tagList = [ tag.strip() for tag in tagString.split(',')]
tagList = [ tag for tag in tagList if tag != '' ]
tagList = list(set(tagList))
setMetaData(metaData, ["org.peerdrive.annotation", "tags"], tagList)
with Connector().update(self.__store, self.__doc, self.__rev) as writer:
writer.writeAll('META', struct.dumps(metaData))
writer.commit()
self.__rev = writer.getRev()
self.__switchStore(self.__store)
def __addReplicateActions(self, menu, link):
c = Connector()
try:
allVolumes = set(c.lookupRev(self.rev()))
if isinstance(link, struct.DocLink):
lookup = c.lookupDoc(link.doc())
curVolumes = set(lookup.stores())
try:
for rev in lookup.revs():
curVolumes = curVolumes & set(c.lookupRev(rev, curVolumes))
except IOError:
curVolumes = set()
else:
curVolumes = set(c.lookupRev(link.rev()))
except IOError:
return
if not curVolumes:
return
srcVol = list(curVolumes)[0]
repVolumes = allVolumes - curVolumes
for store in repVolumes:
try:
rev = c.lookupDoc(store).rev(store)
with c.peek(rev) as r:
metaData = struct.loads(r.readAll('META'))
try:
name = metaData["org.peerdrive.annotation"]["title"]
except:
name = "Unknown store"
action = menu.addAction("Replicate item to '%s'" % name)
action.triggered.connect(
lambda x,l=link,s=store: self.__doReplicate(srcVol, l, s))
except:
pass
parser.error("incorrect number of arguments")
try:
link = struct.Link(args[0])
except IOError as e:
parser.error(str(e))
# mounted through user space file system?
path = fuse.findFuseFile(link)
if not path:
s = Connector().stat(link.rev())
hash = s.hash('FILE')
name = hash.encode('hex')
ext = ""
with Connector().peek(link.store(), link.rev()) as r:
meta = struct.loads(link.store(), r.readAll('META'))
# first look into annotation meta data
if "org.peerdrive.annotation" in meta:
annotation = meta["org.peerdrive.annotation"]
# read title
if "title" in annotation:
(name, ext) = os.path.splitext(annotation["title"])
# try to get extension from Registry if title has none
if not ext:
extensions = Registry().search(s.type(), "extensions")
if extensions:
ext = extensions[0]
# try to get extension from origin if we don't have one already
if not ext and ("origin" in annotation):
state = ""
if enum.isMounted(store):
state += 'M'
else:
state += '-'
if enum.isSystem(store):
state += 'S'
else:
state += '-'
if enum.isRemovable(store):
state += 'R'
else:
state += '-'
if enum.isNet(store):
state += 'N'
else:
state += '-'
if enum.isMounted(store):
sid = enum.doc(store)
try:
rev = Connector().lookupDoc(sid, [sid]).rev(sid)
with Connector().peek(sid, rev) as r:
metaData = struct.loads(sid, r.readAll('META'))
realName = metaData["org.peerdrive.annotation"]["title"]
except IOError as err:
realName = "unknwown (" + str(err) + ")"
print "%s %s %s %s [%s]" % (state, store.ljust(8), sid.encode("hex"), realName, mountName)
else:
print "%s %s [%s]" % (state, store.ljust(8), mountName)
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
from peerdrive import Connector, struct
if len(sys.argv) == 2:
try:
Connector().mount(sys.argv[1])
except IOError as error:
print "Mount failed: " + str(error)
sys.exit(2)
sid = Connector().enum().doc(sys.argv[1])
try:
rev = Connector().lookupDoc(sid, [sid]).rev(sid)
with Connector().peek(sid, rev) as r:
metaData = struct.loads(sid, r.readAll("META"))
name = metaData["org.peerdrive.annotation"]["title"]
except IOError:
name = "Unnamed store"
print "Mounted '%s'" % name
else:
print "Usage: hp-mount.py <id>"
sys.exit(1)
