1
2
3
4
5 from zope.interface import interface, implements
6 from twisted.python import reflect, log
7 from twisted.python.components import registerAdapter
8 from twisted.internet import defer
9
10 import slicer, tokens
11 from tokens import BananaError, Violation
12 from foolscap.constraint import OpenerConstraint, IConstraint, Optional
13
14 Interface = interface.Interface
15
16
17
18
20 """I represent an object which is passed-by-value across PB connections.
21 """
22
24 """Return a string which names the class. This string must match the
25 one that gets registered at the receiving end. This is typically a
26 URL of some sort, in a namespace which you control."""
28 """Return a state dictionary (with plain-string keys) which will be
29 serialized and sent to the remote end. This state object will be
30 given to the receiving object's setCopyableState method."""
31
33 implements(ICopyable)
34
35
37 try:
38 copytype = self.typeToCopy
39 except AttributeError:
40 raise RuntimeError("Copyable subclasses must specify 'typeToCopy'")
41 return copytype
44
46 """I handle ICopyable objects (things which are copied by value)."""
47 - def slice(self, streamable, banana):
59 registerAdapter(CopyableSlicer, ICopyable, tokens.ISlicer)
60
61
63
64
65
67 return reflect.qual(self.__class__)
70 - def slice(self, streamable, banana):
77
78
79
80
82 """This is a shortcut for arranging to serialize third-party clases.
83 'copier' must be a callable which accepts an instance of the class you
84 want to serialize, and returns a tuple of (typename, state_dictionary).
85 If it returns a typename of None, the original class's fully-qualified
86 classname is used.
87 """
88 klassname = reflect.qual(klass)
89 class _CopierAdapter:
90 implements(ICopyable)
91 def __init__(self, original):
92 self.nameToCopy, self.state = copier(original)
93 if self.nameToCopy is None:
94 self.nameToCopy = klassname
95 def getTypeToCopy(self):
96 return self.nameToCopy
97 def getStateToCopy(self):
98 return self.state
99 registerAdapter(_CopierAdapter, klass, ICopyable)
100
101
102
103
105 attrname = None
106 attrConstraint = None
107
108 - def __init__(self, factory, stateSchema):
111
113 self.d = {}
114 self.count = count
115 self.deferred = defer.Deferred()
116 self.protocol.setObject(count, self.deferred)
117
125
134
156
159
161 try:
162 obj = self.factory(self.d)
163 except:
164 log.msg("%s.receiveClose: problem in factory %s" %
165 (self.__class__.__name__, self.factory))
166 log.err()
167 raise
168 self.protocol.setObject(self.count, obj)
169 self.deferred.callback(obj)
170 return obj, None
171
173 if self.classname == None:
174 return "<??>"
175 me = "<%s>" % self.classname
176 if self.attrname is None:
177 return "%s.attrname??" % me
178 else:
179 return "%s.%s" % (me, self.attrname)
180
181
183
184
185
186
187
188
189
191 self.d = {}
192 self.count = count
193 self.gettingAttrname = True
194
196 obj = self.factory(self.d)
197 return obj, None
198
199
201 """This interface defines what a RemoteCopy class must do. RemoteCopy
202 subclasses are used as factories to create objects that correspond to
203 Copyables sent over the wire.
204
205 Note that the constructor of an IRemoteCopy class will be called without
206 any arguments.
207 """
208
210 """I accept an attribute dictionary name/value pairs and use it to
211 set my internal state.
212
213 Some of the values may be Deferreds, which are placeholders for the
214 as-yet-unreferenceable object which will eventually go there. If you
215 receive a Deferred, you are responsible for adding a callback to
216 update the attribute when it fires. [note:
217 RemoteCopyUnslicer.receiveChild currently has a restriction which
218 prevents this from happening, but that may go away in the future]
219
220 Some of the objects referenced by the attribute values may have
221 Deferreds in them (e.g. containers which reference recursive tuples).
222 Such containers are responsible for updating their own state when
223 those Deferreds fire, but until that point their state is still
224 subject to change. Therefore you must be careful about how much state
225 inspection you perform within this method."""
226
227 stateSchema = interface.Attribute("""I return an AttributeDictConstraint
228 object which places restrictions on incoming attribute values. These
229 restrictions are enforced as the tokens are received, before the state is
230 passed to setCopyableState.""")
231
232
233
234 CopyableRegistry = {}
237 """Tell PB that unslicerfactory can be used to handle Copyable objects
238 that provide a getTypeToCopy name of 'typename'. 'unslicerfactory' must
239 be a callable which takes no arguments and returns an object which
240 provides IUnslicer.
241 """
242 assert callable(unslicerfactory)
243
244
245 test_unslicer = unslicerfactory()
246 assert tokens.IUnslicer.providedBy(test_unslicer)
247 assert type(typename) is str
248
249 if registry == None:
250 registry = CopyableRegistry
251 assert not registry.has_key(typename)
252 registry[typename] = unslicerfactory
253
254
255 debug_CopyableFactories = {}
258 """Tell PB that 'factory' can be used to handle Copyable objects that
259 provide a getTypeToCopy name of 'typename'. 'factory' must be a callable
260 which accepts a state dictionary and returns a fully-formed instance.
261
262 'cyclic' is a boolean, which should be set to False to avoid using a
263 Deferred to provide the resulting RemoteCopy instance. This is needed to
264 deserialize Failures (or instances which inherit from one, like
265 CopiedFailure). In exchange for this, it cannot handle reference cycles.
266 """
267 assert callable(factory)
268 debug_CopyableFactories[typename] = (factory, stateSchema, cyclic)
269 if cyclic:
270 def _RemoteCopyUnslicerFactory():
271 return RemoteCopyUnslicer(factory, stateSchema)
272 registerRemoteCopyUnslicerFactory(typename,
273 _RemoteCopyUnslicerFactory,
274 registry)
275 else:
276 def _RemoteCopyUnslicerFactoryNonCyclic():
277 return NonCyclicRemoteCopyUnslicer(factory, stateSchema)
278 registerRemoteCopyUnslicerFactory(typename,
279 _RemoteCopyUnslicerFactoryNonCyclic,
280 registry)
281
282
283
284
285 debug_RemoteCopyClasses = {}
287 """Tell PB that remote_copy_class is the appropriate RemoteCopy class to
288 use when deserializing a Copyable sequence that is tagged with
289 'typename'. 'remote_copy_class' should be a RemoteCopy subclass or
290 implement the same interface, which means its constructor takes no
291 arguments and it has a setCopyableState(state) method to actually set the
292 instance's state after initialization. It must also have a nonCyclic
293 attribute.
294 """
295 assert IRemoteCopy.implementedBy(remote_copy_class)
296 assert type(typename) is str
297
298 debug_RemoteCopyClasses[typename] = remote_copy_class
299 def _RemoteCopyFactory(state):
300 obj = remote_copy_class()
301 obj.setCopyableState(state)
302 return obj
303
304 registerRemoteCopyFactory(typename, _RemoteCopyFactory,
305 remote_copy_class.stateSchema,
306 not remote_copy_class.nonCyclic,
307 registry)
308
325
339
344
353
354
356 """This is a constraint for dictionaries that are used for attributes.
357 All keys are short strings, and each value has a separate constraint.
358 It could be used to describe instance state, but could also be used
359 to constraint arbitrary dictionaries with string keys.
360
361 Some special constraints are legal here: Optional.
362 """
363 opentypes = [("attrdict",)]
364 name = "AttributeDictConstraint"
365
366 - def __init__(self, *attrTuples, **kwargs):
374
387
389 if type(obj) != type({}):
390 raise Violation, "'%s' (%s) is not a Dictionary" % (obj,
391 type(obj))
392 allkeys = self.keys.keys()
393 for k in obj.keys():
394 try:
395 constraint = self.keys[k]
396 allkeys.remove(k)
397 except KeyError:
398 if not self.ignoreUnknown:
399 raise Violation, "key '%s' not in schema" % k
400 else:
401
402 pass
403 else:
404 constraint.checkObject(obj[k], inbound)
405
406 for k in allkeys[:]:
407 if isinstance(self.keys[k], Optional):
408 allkeys.remove(k)
409 if allkeys:
410 raise Violation("object is missing required keys: %s" % \
411 ",".join(allkeys))
412