Mercurial > libervia-pubsub
comparison idavoll/memory_storage.py @ 206:274a45d2a5ab
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 """ |