def _testTracingOrProfileState(self, do_pickle=False, **kw):
t = tasklet(self.Tasklet)
t(**kw)
t.run()
self.foo()
n = len(self.trace)
self.foo()
n2 = len(self.trace)
self.assertEqual(n, n2)
if do_pickle:
io = StringIO()
p = Pickler(io, -1)
p.persistent_id = self.persistent_id
p.dump(t)
t.remove()
t.bind(None)
p = Unpickler(StringIO(io.getvalue()))
p.persistent_load = self.persistent_load
t = p.load()
p = None
io = None
t.run()
self.foo()
n = len(self.trace)
self.foo()
n2 = len(self.trace)
self.assertEqual(n, n2)
def _testTracingOrProfileState(self, do_pickle=False, **kw):
t = tasklet(self.Tasklet)
t(**kw)
t.run()
self.foo()
n = len(self.trace)
self.foo()
n2 = len(self.trace)
self.assertEqual(n, n2)
if do_pickle:
io = StringIO()
p = Pickler(io, -1)
p.persistent_id = self.persistent_id
p.dump(t)
t.remove()
t.bind(None)
p = Unpickler(StringIO(io.getvalue()))
p.persistent_load = self.persistent_load
t = p.load()
p = None
io = None
t.run()
self.foo()
n = len(self.trace)
self.foo()
n2 = len(self.trace)
self.assertEqual(n, n2)
def save(obj, filename):
print "* Saving..."
setrecursionlimit(10000)
copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)
out_file = open(filename, "wb")
pickler = Pickler(out_file, -1)
pickler.persistent_id = persistent_id
pickler.dump(obj)
out_file.close()
print "* Saved!"
def dump(obj):
print "* Dumping..."
setrecursionlimit(10000)
copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)
pickle_buffer = StringIO()
pickler = Pickler(pickle_buffer, -1)
pickler.persistent_id = persistent_id
pickler.dump(obj)
print "* Dumped!"
return pickle_buffer
def tokens_referenced(self):
"""
Return a list of all the tokens that are referenced (i.e. contained in)
this message. Tokens that haven't been assigned an id yet are searched
recursively for tokens. So this method may return fewer results after
the message is sent. This information is used by the game engine to
catch mistakes like forgetting to add a token to the world or keeping a
stale reference to a token after its been removed.
"""
tokens = set()
# Use the pickle machinery to find all the tokens contained at any
# level of this message. When an object is being pickled, the Pickler
# calls its persistent_id() method for each object it encounters. We
# hijack this method to add every Token we encounter to a list.
# This definitely feels like a hacky abuse of the pickle machinery, but
# that notwithstanding this should be quite robust and quite fast.
def persistent_id(obj):
from .tokens import Token
if isinstance(obj, Token):
tokens.add(obj)
# Recursively descend into tokens that haven't been assigned an
# id yet, but not into tokens that have.
return obj.id
from pickle import Pickler
from io import BytesIO
# Use BytesIO to basically ignore the serialized data stream, since we
# only care about visiting all the objects that would be pickled.
pickler = Pickler(BytesIO())
pickler.persistent_id = persistent_id
pickler.dump(self)
return tokens
def _cloneByPickle(self, obj):
"""Returns a deep copy of a ZODB object, loading ghosts as needed.
"""
modifier = getToolByName(self, 'portal_modifier')
callbacks = modifier.getOnCloneModifiers(obj)
if callbacks is not None:
pers_id, pers_load, inside_orefs, outside_orefs = callbacks[0:4]
else:
inside_orefs, outside_orefs = (), ()
stream = StringIO()
p = Pickler(stream, 1)
if callbacks is not None:
p.persistent_id = pers_id
p.dump(aq_base(obj))
approxSize = stream.tell()
stream.seek(0)
u = Unpickler(stream)
if callbacks is not None:
u.persistent_load = pers_load
return approxSize, u.load(), inside_orefs, outside_orefs
def pack(self, message):
from pickle import Pickler
from io import BytesIO
from .tokens import Token
from .messages import Message, require_message
buffer = BytesIO()
delegate = Pickler(buffer)
def persistent_id(token):
if isinstance(token, Token):
assert isinstance(message, Message), msg("""\
Both Message and ServerResponse objects can be
serialized, but only Messages can contain tokens.""")
assert token.id, msg("""\
Every token should have an id by now. Tokens that are
in the world should always have an id, and tokens that
are being added to the world should've been assigned an
id by Actor.send_message().""")
if token in self.world:
assert token not in message.tokens_to_add(), msg("""\
Actor.send_message() should've refused to send a
message that would add a token that's already in
the world.""")
return token.id
else:
assert token in message.tokens_to_add(), msg("""\
Actor.send_message() should've refused to send a
message referencing tokens that aren't in the world
and aren't being added to the world.""")
return None
delegate.persistent_id = persistent_id
delegate.dump(message)
return buffer.getvalue()
def testExceptionStatePickled(self):
if not enable_softswitch(None):
return
t = tasklet(self.Tasklet)
sys.exc_clear()
t()
t.run()
io = StringIO()
p = Pickler(io, -1)
p.persistent_id = self.persistent_id
p.dump(t)
t.remove()
t.bind(None)
p = Unpickler(StringIO(io.getvalue()))
p.persistent_load = self.persistent_load
t = p.load()
p = None
io = None
self.ran = False
t.run()
self.assertTrue(self.ran)
ei = sys.exc_info()
self.assertEqual(ei, (None, ) * 3)
def testExceptionStatePickled(self):
if not enable_softswitch(None):
return
t = tasklet(self.Tasklet)
sys.exc_clear()
t()
t.run()
io = StringIO()
p = Pickler(io, -1)
p.persistent_id = self.persistent_id
p.dump(t)
t.remove()
t.bind(None)
p = Unpickler(StringIO(io.getvalue()))
p.persistent_load = self.persistent_load
t = p.load()
p = None
io = None
self.ran = False
t.run()
self.assertTrue(self.ran)
ei = sys.exc_info()
self.assertEqual(ei, (None,) * 3)
def dumps(self, obj, protocol=None, bin=None):
src = BytesIO()
p = Pickler(src)
p.persistent_id = self._get_ids
p.dump(obj)
return src.getvalue()
def dumps(self, graph, protocol):
src = StringIO()
pickler = Pickler(src)
pickler.persistent_id = self.persistent_id
pickler.dump(graph)
return src.getvalue()
def dumps(self, graph, protocol):
src = StringIO()
pickler = Pickler(src)
pickler.persistent_id = self.persistent_id
pickler.dump(graph)
return src.getvalue()
def dumps(self, obj, protocol=None, bin=None):
src = BytesIO()
p = Pickler(src)
p.persistent_id = self._get_ids
p.dump(obj)
return src.getvalue()
