def _configDocChanged(self, pillow, doc):
self._configDoc = doc
if doc != None and doc.get("widgets." + self._template) == None:
doc.set("widgets." + self._template, self._config)
House.get("__CONFIG__").throw(Editor.Out.FieldChanged, "widgets." + self._template)
self._configChanged(None, "widgets." + self._template)
def registerConfigViewer(self):
self._template = self.getWallabyTemplate()
if self._template is None:
self._template = unicode(self.objectName())
if not self._configViewerRegistered:
self._configViewerRegistered = True
House.get("__CONFIG__").catch(Viewer.In.Refresh, self._configChanged)
House.get("__CONFIG__").catch(Viewer.In.Document, self._configDocChanged)
def __addPeer(self, room, name, config):
if self._state not in ("Edit", "New", "Dirty"):
from wallaby.qt_combat import QtGui
import wallaby.FX as FX
reply = QtGui.QMessageBox.question(FX.mainWindow, 'Edit configuration',
"You must edit the configuration to add peers. Do you want to edit?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
from wallaby.pf.peer.editDocument import EditDocument
self.throw(EditDocument.In.Edit, None)
else:
return
from wallaby.pf.peer.documentChanger import DocumentChanger
self.throw(DocumentChanger.In.InsertRow, ("rooms.*.Peers", {"name": name, "config": config}))
from wallaby.pf.room import House
observer = House.observer()
cls = observer.peerClass(name)
try:
for dep in cls.Dependencies:
observer = House.observer()
cls2 = observer.peerClass(dep)
config = {}
try:
description = cls2.Description
if isinstance(description, (list, tuple)):
description, config = description
except: pass
print "Looking for", dep, "in", House.get(room).allPeers()
if dep in House.get(room).allPeers():
continue
found = False
for peer in House.get(room).allPeers():
if dep == peer.__class__.__name__:
found = True
break
if found: continue
self.__addPeer(room, dep, config)
except: pass
def __init__(self, srcRoom, dstRoom, pillow):
Peer.__init__(self, srcRoom)
from wallaby.pf.room import House
self._dstRoom = House.get(dstRoom)
self._catch(pillow, self._message)
def __init__(self, room, dstRoom=None):
Peer.__init__(self, room)
self._document = None
self._dstRoom = None
if dstRoom != None:
from wallaby.pf.room import House
self._dstRoom = House.get(dstRoom)
self._catch(DocumentChanger.In.Change, self._change)
self._catch(DocumentChanger.In.Edit, self._edit)
self._catch(DocumentChanger.In.Clone, self._clone)
self._catch(DocumentChanger.In.SubClone, self._subClone)
self._catch(DocumentChanger.In.Embed, self._embed)
self._catch(Viewer.In.Document, self._setDocument)
self._catch(DocumentChanger.In.InsertRow, self._insertRow)
self._catch(DocumentChanger.In.RemoveRow, self._removeRow)
self._catch(DocumentChanger.In.InsertKey, self._insertKey)
self._catch(DocumentChanger.In.RemoveKey, self._removeKey)
self._catch(DocumentChanger.In.MoveUp, self._up)
self._catch(DocumentChanger.In.MoveDown, self._down)
self._catch(DocumentChanger.In.Select, self._select)
def initialize(self):
from wallaby.pf.room import House
observer = House.observer()
from wallaby.common.document import Document
doc = Document()
peerNames = sorted(observer.allPeers().keys())
peers = []
for peer in peerNames:
ibp = observer.inBoundPillows(peer)
obp = observer.outBoundPillows(peer)
peers.append({
"name": peer,
"inBound": ibp,
"outBound": obp
})
doc.set("peers", peers)
self._throw(Viewer.In.Document, doc)
# Wildcard credentials
from credentials import Credentials
self._throw(Credentials.Out.Credential, Document())
def test_02_view(self):
global factory
peers = ["ViewDocument", "DocumentCache", "DocumentDatabase", "CouchDB"]
for p in peers:
factory.peer(p, "room01")
CredentialsParty()
d = defer.Deferred()
def callback(value):
if value:
d.callback(value)
from wallaby.pf.peer.viewer import Viewer
Viewer("room01", callback, "text")
House.initializeAll()
Peer.initializeAll()
yield sleep(0.1)
from wallaby.pf.peer.editDocument import EditDocument
room = House.get("room01")
room.throw(EditDocument.In.Load, self._docId)
value = yield d
self.assertEqual(value, "Hello World!")
House.destroyRoom("room01")
House.destroyRoom("__CREDENTIALS__")
def test_03_edit(self):
global factory
peers = ["EditDocument", "DocumentCache", "DocumentDatabase", "CouchDB"]
for p in peers:
factory.peer(p, "room01")
CredentialsParty()
valueDeferred = defer.Deferred()
def valueCallback(value):
if value == "Hello Jan":
try:
valueDeferred.callback(value)
except:
pass
setRODeferred = defer.Deferred()
def roCallback(readOnly):
if not readOnly:
try:
setRODeferred.callback(readOnly)
except:
pass
from wallaby.pf.peer.viewer import Viewer
from wallaby.pf.peer.editor import Editor
Viewer("room01", valueCallback, "text")
editor = Editor("room01", path="text", setReadOnlyCallback=roCallback)
House.initializeAll()
Peer.initializeAll()
yield sleep(0.1)
from wallaby.pf.peer.editDocument import EditDocument
room = House.get("room01")
room.throw(EditDocument.In.LoadAndEdit, self._docId)
yield setRODeferred
editor.changeValue("Hello Jan")
value = yield valueDeferred
self.assertEqual(value, "Hello Jan")
room.throw(EditDocument.In.Save, self._docId)
from wallaby.pf.peer.database import Database
docId = yield room.catchNow(Database.Out.DocumentSaved)
self.assertEqual(docId, self._docId)
doc = yield self._db.get(self._docId)
self.assertEqual(doc["text"], "Hello Jan")
House.destroyRoom("room01")
House.destroyRoom("__CREDENTIALS__")
def __init__(self, srcRoom, dstRoom=None, viewIdentifier=None):
Peer.__init__(self, srcRoom)
from wallaby.pf.room import House
self._dstRoom = House.get(dstRoom)
self._viewIdentifier = viewIdentifier
self._documentID = None
self._queryDoc = None
self._queryRoom = None
self._catch(Viewer.In.Document, self._docChanged)
self._catch(Relation.In.Add, self._add)
self._catch(Relation.In.AddAndSave, self._addAndSave)
if viewIdentifier != None:
self._queryRoom = House.get(self._viewIdentifier.upper())
if self._queryRoom:
self._queryRoom.catch(Viewer.In.Document, self._queryDocChanged)
def _configChanged(self, pillow, path):
if not self._configDoc or not Viewer.matchPath("widgets." + self._template, path): return
config = self._configDoc.get("widgets." + self._template)
if config is not None:
import json
if self._lastConfig == None or json.dumps(self._lastConfig, sort_keys=True) != json.dumps(config, sort_keys=True):
for k, v in config.items():
if k == "wallabyType" or (k in self.wallabyProperties and self.wallabyProperties[k].readOnly):
continue
self._config[k] = v
for k, v in self._config.items():
if k == "wallabyType" or (k in self.wallabyProperties and self.wallabyProperties[k].readOnly) or k not in config:
config[k] = v
self._lastConfig = copy.deepcopy(config)
if self.room != None and len(self.room) > 0: House.get(self.room) # Implicit room creation...
self.deregister()
self.register()
def __init__(self, room, cb, feathers):
Peer.__init__(self, room)
self._cb = cb
self._feathers = {}
self._otherFeathers = {}
self._enabled = {}
self._negate = False
self._negateOther = {}
if feathers is None: return
for p in feathers:
if p is None: continue
if ':' in p:
room, p = p.split(':')
if room not in self._otherFeathers: self._otherFeathers[room] = {}
if p.startswith('!'):
p = p[1:]
self._negateOther[room] = True
else:
self._negateOther[room] = False
self._otherFeathers[room][p] = True
else:
if p.startswith('!'):
p = p[1:]
self._negate = True
self._feathers[p] = True
if len(self._otherFeathers) > 0:
if len(self._feathers) > 0:
self._otherFeathers[self._roomName] = self._feathers
self._negateOther[self._roomName] = self._negate
i = 0
for roomName in self._otherFeathers.keys():
self._enabled[roomName] = False
from wallaby.pf.room import House
room = House.get(roomName)
from functools import partial
room.catch(Enabler.In.Enable, partial(self._enableOther, roomName))
else:
self._catch(Enabler.In.Enable, self._enable)
def test_01_database(self):
global factory
peers = ["CouchDB"]
for p in peers:
factory.peer(p, "room01")
House.initializeAll()
Peer.initializeAll()
yield sleep(0.1)
d = defer.Deferred()
room = House.get("room01")
from wallaby.pf.peer.database import Database
room.catch(Database.Out.RequestedDocument, lambda *args: d.callback(args))
room.throw(Database.In.RequestDocument, self._docId)
pillow, doc = yield d
self.assertEqual(doc.documentID, self._docId)
House.destroyRoom("room01")
def __init__(self, roomName):
if roomName == None: roomName = "None"
self.initialized = False
from wallaby.pf.room import House
self.__room = House.get(roomName)
Peer.peers.append(self)
self._roomName = roomName
self._routings = {}
self._peers = []
self._catchers = set()
if 'Routings' in self.__class__.__dict__:
for f, t in self.__class__.Routings:
self._addRouting(f, t)
self.destroyed = False
self.__room.enter(self)
from wallaby.pf.peer.viewer import Viewer
# Copyright (c) by it's authors.
# Some rights reserved. See LICENSE, AUTHORS.
from twisted.internet import defer, reactor
from twisted.trial import unittest
from wallaby.pf.room import House
from wallaby.pf.peer.peer import Peer
from wallaby.pf.peer.credentialsParty import CredentialsParty
factory = House.observer()
def sleep(time):
d = defer.Deferred()
reactor.callLater(time, d.callback, None)
return d
class WallabyCouchDBTest(unittest.TestCase):
def setUp(self):
self._dbName = "wallaby_test"
self._docId = "testdoc"
self.timeout = 1
self._designDoc = {
"_id": "_design/wallaby_test",
"language": "javascript",
"views": {"text": {"map": "function(doc) { if(doc.text)\n emit(doc.text, null);\n}"}},
"filters": {
"typeB": 'function(doc, req) { if((doc.type && doc.type == "typeB") || doc.deleted) { return true; } return false;}'
def _showConflictContextMenu(self, pos):
globalPos = self.mapToGlobal(pos)
if not self._hasConflict:
menuEntries = self.getMenuEntries()
if menuEntries == None or len(menuEntries) == 0:
return
menu = QtGui.QMenu(self)
for label, action in menuEntries.items():
pillow = action
feathers = None
if isinstance(action, (list, tuple)):
if len(action) == 2:
pillow, feathers = action
else:
pillow = action.pop(0)
act = menu.addAction(label)
act.pillow = pillow
act.feathers = feathers
action = menu.exec_(globalPos)
if action != None:
House.get(self.room).throw(action.pillow, act.feathers)
return
menu = QtGui.QMenu()
if isinstance(self._currentValue, (list, dict)):
mineAction = QtGui.QAction(FXUI.mineIcon, "use " + str(len(self._currentValue)) + " Item(s) (mine)", self)
else:
mineAction = QtGui.QAction(FXUI.mineIcon, "use >" + unicode(self._currentValue) + "< (mine)", self)
menu.addAction(mineAction)
mineAllAction = QtGui.QAction(FXUI.mineIcon, "use mine", self)
menu.addAction(mineAllAction)
theirsAction = []
theirsAllAction = []
for user, c in self._conflictValues:
if user == None: user = "******"
if isinstance(c, (list, dict)):
act = QtGui.QAction(FXUI.theirsIcon, "use " + str(len(c)) + " Item(s) ("+user+")", self)
else:
act = QtGui.QAction(FXUI.theirsIcon, "use >" + unicode(c) + "< ("+user+")", self)
theirsAction.append(act)
menu.addAction(act)
act = QtGui.QAction(FXUI.theirsIcon, "use theirs ("+user+")", self)
theirsAllAction.append(act)
menu.addAction(act)
act = menu.exec_(globalPos)
if act != None:
if act == mineAllAction:
self._resolve(self._currentValue, mine=True)
elif act == mineAction:
self._resolve(self._currentValue)
else:
if act in theirsAction:
idx = theirsAction.index(act)
self._resolve(self._conflictValues[idx][1])
else:
idx = theirsAllAction.index(act)
self._resolve(self._conflictValues[idx][1], theirs=idx)
self._conflict(False, self._currentValue, self._conflictValues)
def _newSuggest(self, pillow, doc):
self._suggests = doc
House.get("__SUGGEST__").throw(Viewer.In.Document, doc)
