Mercurial > libervia-pubsub

comparison idavoll/memory_storage.py @ 206:274a45d2a5ab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Implement root collection that includes all leaf nodes.
author Ralph Meijer <ralphm@ik.nu>
date Mon, 04 Aug 2008 13:47:10 +0000
parents b4bf0a5ce50d
children aecfacb5a571
comparison
equal deleted inserted replaced
205:e6b710bf2b24 206:274a45d2a5ab
4 import copy 4 import copy
5 from zope.interface import implements 5 from zope.interface import implements
6 from twisted.internet import defer 6 from twisted.internet import defer
7 from twisted.words.protocols.jabber import jid 7 from twisted.words.protocols.jabber import jid
8 8
9 from wokkel.pubsub import Subscription
10
9 from idavoll import error, iidavoll 11 from idavoll import error, iidavoll
10 12
11 defaultConfig = {"pubsub#persist_items": True,
12 "pubsub#deliver_payloads": True,
13 "pubsub#send_last_published_item": 'on_sub',
14 "pubsub#node_type": "leaf"}
15
16 class Storage: 13 class Storage:
17 14
18 implements(iidavoll.IStorage) 15 implements(iidavoll.IStorage)
19 16
17 defaultConfig = {
18 'leaf': {
19 "pubsub#persist_items": True,
20 "pubsub#deliver_payloads": True,
21 "pubsub#send_last_published_item": 'on_sub',
22 },
23 'collection': {
24 "pubsub#deliver_payloads": True,
25 "pubsub#send_last_published_item": 'on_sub',
26 }
27 }
28
20 def __init__(self): 29 def __init__(self):
21 self._nodes = {} 30 rootNode = CollectionNode('', jid.JID('localhost'),
31 copy.copy(self.defaultConfig['collection']))
32 self._nodes = {'': rootNode}
22 33
23 34
24 def getNode(self, nodeIdentifier): 35 def getNode(self, nodeIdentifier):
25 try: 36 try:
26 node = self._nodes[nodeIdentifier] 37 node = self._nodes[nodeIdentifier]
32 43
33 def getNodeIds(self): 44 def getNodeIds(self):
34 return defer.succeed(self._nodes.keys()) 45 return defer.succeed(self._nodes.keys())
35 46
36 47
37 def createNode(self, nodeIdentifier, owner, config=None): 48 def createNode(self, nodeIdentifier, owner, config):
38 if nodeIdentifier in self._nodes: 49 if nodeIdentifier in self._nodes:
39 return defer.fail(error.NodeExists()) 50 return defer.fail(error.NodeExists())
40 51
41 if not config:
42 config = copy.copy(defaultConfig)
43
44 if config['pubsub#node_type'] != 'leaf': 52 if config['pubsub#node_type'] != 'leaf':
45 raise NotImplementedError 53 raise error.NoCollections()
46 54
47 node = LeafNode(nodeIdentifier, owner, config) 55 node = LeafNode(nodeIdentifier, owner, config)
48 self._nodes[nodeIdentifier] = node 56 self._nodes[nodeIdentifier] = node
49 57
50 return defer.succeed(None) 58 return defer.succeed(None)
70 subscriptions = [] 78 subscriptions = []
71 for node in self._nodes.itervalues(): 79 for node in self._nodes.itervalues():
72 for subscriber, subscription in node._subscriptions.iteritems(): 80 for subscriber, subscription in node._subscriptions.iteritems():
73 subscriber = jid.internJID(subscriber) 81 subscriber = jid.internJID(subscriber)
74 if subscriber.userhostJID() == entity.userhostJID(): 82 if subscriber.userhostJID() == entity.userhostJID():
75 subscriptions.append((node.nodeIdentifier, subscriber, 83 subscriptions.append(subscription)
76 subscription.state))
77 84
78 return defer.succeed(subscriptions) 85 return defer.succeed(subscriptions)
79 86
87
88 def getDefaultConfiguration(self, nodeType):
89 if nodeType == 'collection':
90 raise error.NoCollections()
91
92 return self.defaultConfig[nodeType]
80 93
81 94
82 class Node: 95 class Node:
83 96
84 implements(iidavoll.INode) 97 implements(iidavoll.INode)
118 131
119 def getSubscription(self, subscriber): 132 def getSubscription(self, subscriber):
120 try: 133 try:
121 subscription = self._subscriptions[subscriber.full()] 134 subscription = self._subscriptions[subscriber.full()]
122 except KeyError: 135 except KeyError:
123 state = None 136 return defer.succeed(None)
124 else: 137 else:
125 state = subscription.state 138 return defer.succeed(subscription)
126 return defer.succeed(state) 139
127 140
128 141 def getSubscriptions(self, state=None):
129 def addSubscription(self, subscriber, state): 142 return defer.succeed(
143 [subscription
144 for subscription in self._subscriptions.itervalues()
145 if state is None or subscription.state == state])
146
147
148
149 def addSubscription(self, subscriber, state, options):
130 if self._subscriptions.get(subscriber.full()): 150 if self._subscriptions.get(subscriber.full()):
131 return defer.fail(error.SubscriptionExists()) 151 return defer.fail(error.SubscriptionExists())
132 152
133 subscription = Subscription(state) 153 subscription = Subscription(self.nodeIdentifier, subscriber, state,
154 options)
134 self._subscriptions[subscriber.full()] = subscription 155 self._subscriptions[subscriber.full()] = subscription
135 return defer.succeed(None) 156 return defer.succeed(None)
136 157
137 158
138 def removeSubscription(self, subscriber): 159 def removeSubscription(self, subscriber):
140 del self._subscriptions[subscriber.full()] 161 del self._subscriptions[subscriber.full()]
141 except KeyError: 162 except KeyError:
142 return defer.fail(error.NotSubscribed()) 163 return defer.fail(error.NotSubscribed())
143 164
144 return defer.succeed(None) 165 return defer.succeed(None)
145
146
147 def getSubscribers(self):
148 subscribers = [jid.internJID(subscriber) for subscriber, subscription
149 in self._subscriptions.iteritems()
150 if subscription.state == 'subscribed']
151
152 return defer.succeed(subscribers)
153 166
154 167
155 def isSubscribed(self, entity): 168 def isSubscribed(self, entity):
156 for subscriber, subscription in self._subscriptions.iteritems(): 169 for subscriber, subscription in self._subscriptions.iteritems():
157 if jid.internJID(subscriber).userhost() == entity.userhost() and \ 170 if jid.internJID(subscriber).userhost() == entity.userhost() and \
185 self.element = element 198 self.element = element
186 self.publisher = publisher 199 self.publisher = publisher
187 200
188 201
189 202
190 class LeafNodeMixin: 203 class LeafNode(Node):
204
205 implements(iidavoll.ILeafNode)
191 206
192 nodeType = 'leaf' 207 nodeType = 'leaf'
193 208
194 def __init__(self): 209 def __init__(self, nodeIdentifier, owner, config):
210 Node.__init__(self, nodeIdentifier, owner, config)
195 self._items = {} 211 self._items = {}
196 self._itemlist = [] 212 self._itemlist = []
197 213
198 214
199 def storeItems(self, items, publisher): 215 def storeItems(self, items, publisher):
249 self._itemlist = [] 265 self._itemlist = []
250 266
251 return defer.succeed(None) 267 return defer.succeed(None)
252 268
253 269
254 270 class CollectionNode(Node):
255 class LeafNode(Node, LeafNodeMixin): 271 nodeType = 'collection'
256
257 implements(iidavoll.ILeafNode)
258
259 def __init__(self, nodeIdentifier, owner, config):
260 Node.__init__(self, nodeIdentifier, owner, config)
261 LeafNodeMixin.__init__(self)
262
263
264
265 class Subscription:
266
267 def __init__(self, state):
268 self.state = state
269 272
270 273
271 274
272 class GatewayStorage(object): 275 class GatewayStorage(object):
273 """ 276 """