def test_classSecurity(self):
"""
Test for class-level security of serialization.
"""
taster = jelly.SecurityOptions()
taster.allowInstancesOf(A, B)
a = A()
b = B()
c = C()
# add a little complexity to the data
a.b = b
a.c = c
# and a backreference
a.x = b
b.c = c
# first, a friendly insecure serialization
friendly = jelly.jelly(a, taster)
x = jelly.unjelly(friendly, taster)
self.assertIsInstance(x.c, jelly.Unpersistable)
# now, a malicious one
mean = jelly.jelly(a)
self.assertRaises(jelly.InsecureJelly, jelly.unjelly, mean, taster)
self.assertIdentical(x.x, x.b, "Identity mismatch")
# test class serialization
friendly = jelly.jelly(A, taster)
x = jelly.unjelly(friendly, taster)
self.assertIdentical(x, A, "A came back: %s" % x)
def testClassSecurity(self):
"""
test for class-level security of serialization
"""
taster = jelly.SecurityOptions()
taster.allowInstancesOf(A, B)
a = A()
b = B()
c = C()
# add a little complexity to the data
a.b = b
a.c = c
# and a backreference
a.x = b
b.c = c
# first, a friendly insecure serialization
friendly = jelly.jelly(a, taster)
x = jelly.unjelly(friendly, taster)
assert isinstance(x.c, jelly.Unpersistable), "C came back: %s" % x.c.__class__
# now, a malicious one
mean = jelly.jelly(a)
try:
x = jelly.unjelly(mean, taster)
assert 0, "x came back: %s" % x
except jelly.InsecureJelly:
# OK
pass
assert x.x is x.b, "Identity mismatch"
def testLotsaTypes(self):
"""
test for all types currently supported in jelly
"""
a = A()
jelly.unjelly(jelly.jelly(a))
jelly.unjelly(jelly.jelly(a.amethod))
items = [afunc, [1, 2, 3], not bool(1), bool(1), 'test', 20.3, (1,2,3), None, A, unittest, {'a':1}, A.amethod]
for i in items:
self.assertEquals(i, jelly.unjelly(jelly.jelly(i)))
def testSerialize(self):
text = N_("Something is really wrong.")
self.cmsg = messages.Error(T_(text))
self.mmsg = jelly.unjelly(jelly.jelly(self.cmsg))
t = self.mmsg.translatables[0]
self.assertEquals(t.format, "Something is really wrong.")
self.assertEquals(self.mmsg.level, messages.ERROR)
self.amsg = jelly.unjelly(jelly.jelly(self.mmsg))
t = self.amsg.translatables[0]
self.assertEquals(t.format, "Something is really wrong.")
self.assertEquals(self.amsg.level, messages.ERROR)
def test_oldSets(self):
"""
Test jellying C{sets.Set}: it should serialize to the same thing as
C{set} jelly, and be unjellied as C{set} if available.
"""
inputList = [jelly._sets.Set([1, 2, 3])]
inputJelly = jelly.jelly(inputList)
self.assertEqual(inputJelly, jelly.jelly([set([1, 2, 3])]))
output = jelly.unjelly(inputJelly)
# Even if the class is different, it should coerce to the same list
self.assertEqual(list(inputList[0]), list(output[0]))
if set is jelly._sets.Set:
self.assertIsInstance(output[0], jelly._sets.Set)
else:
self.assertIsInstance(output[0], set)
def save(self, statefile=None):
"""Save state as a pickled jelly to a file on disk."""
if not statefile:
if not self._statefile:
raise MissingState("Could not find a state file to load.")
statefile = self._statefile
logging.debug("Saving state to: \t'%s'" % statefile)
fh = None
err = ''
try:
fh = open(statefile, 'w')
except MissingState as error:
err += error.message
except (IOError, OSError) as error:
err += "Error writing state file to '%s': %s" % (statefile, error)
else:
try:
pickle.dump(jelly.jelly(self), fh)
except AttributeError as error:
logging.debug("Tried jellying an unjelliable object: %s"
% error.message)
if fh is not None:
fh.flush()
fh.close()
def test_typeSecurity(self):
"""
Test for type-level security of serialization.
"""
taster = jelly.SecurityOptions()
dct = jelly.jelly({})
self.assertRaises(jelly.InsecureJelly, jelly.unjelly, dct, taster)
def test_twiceUnjelliedFailureCheck(self):
"""
The object which results from jellying a L{CopyableFailure}, unjellying
the result, creating a new L{CopyableFailure} from the result of that,
jellying it, and finally unjellying the result of that has a check
method which behaves the same way as the original L{CopyableFailure}'s
check method.
"""
original = pb.CopyableFailure(ZeroDivisionError())
self.assertIdentical(original.check(ZeroDivisionError), ZeroDivisionError)
self.assertIdentical(original.check(ArithmeticError), ArithmeticError)
copiedOnce = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker()))
derivative = pb.CopyableFailure(copiedOnce)
copiedTwice = jelly.unjelly(jelly.jelly(derivative, invoker=DummyInvoker()))
self.assertIdentical(copiedTwice.check(ZeroDivisionError), ZeroDivisionError)
self.assertIdentical(copiedTwice.check(ArithmeticError), ArithmeticError)
def test_moreReferences(self):
a = []
t = (a,)
a.append((t,))
s = jelly.jelly(t)
z = jelly.unjelly(s)
self.assertIdentical(z[0][0][0], z)
def testInvalidate(self):
mcomp = planet.ManagerComponentState()
mflow = planet.ManagerFlowState()
mstate = planet.ManagerPlanetState()
mflow.append('components', mcomp)
mstate.append('flows', mflow)
astate = jelly.unjelly(jelly.jelly(mstate))
self.failUnless(isinstance(astate, planet.AdminPlanetState))
aflow, = astate.get('flows')
acomp, = aflow.get('components')
invalidates = []
def invalidate(obj):
invalidates.append(obj)
astate.addListener(self, invalidate=invalidate)
aflow.addListener(self, invalidate=invalidate)
acomp.addListener(self, invalidate=invalidate)
self.assertEquals(invalidates, [])
astate.invalidate()
self.assertEquals(invalidates, [acomp, aflow, astate])
def serialize(self, object, perspective=None, method=None, args=None, kw=None):
"""Jelly an object according to the remote security rules for this broker.
"""
if isinstance(object, defer.Deferred):
object.addCallbacks(
self.serialize,
lambda x: x,
callbackKeywords={"perspective": perspective, "method": method, "args": args, "kw": kw},
)
return object
# XXX This call is NOT REENTRANT and testing for reentrancy is just
# crazy, so it likely won't be. Don't ever write methods that call the
# broker's serialize() method recursively (e.g. sending a method call
# from within a getState (this causes concurrency problems anyway so
# you really, really shouldn't do it))
# self.jellier = _NetJellier(self)
self.serializingPerspective = perspective
self.jellyMethod = method
self.jellyArgs = args
self.jellyKw = kw
try:
return jelly(object, self.security, None, self)
finally:
self.serializingPerspective = None
self.jellyMethod = None
self.jellyArgs = None
self.jellyKw = None
def testPersistentStorage(self):
perst = [{}, 1]
def persistentStore(obj, jel, perst = perst):
perst[1] = perst[1] + 1
perst[0][perst[1]] = obj
return str(perst[1])
def persistentLoad(pidstr, unj, perst = perst):
pid = int(pidstr)
return perst[0][pid]
a = SimpleJellyTest(1, 2)
b = SimpleJellyTest(3, 4)
c = SimpleJellyTest(5, 6)
a.b = b
a.c = c
c.b = b
jel = jelly.jelly(a, persistentStore = persistentStore)
x = jelly.unjelly(jel, persistentLoad = persistentLoad)
assert x.b is x.c.b, "Identity failure."
# assert len(perst) == 3, "persistentStore should only be called 3 times."
assert perst[0], "persistentStore was not called."
assert x.b is a.b, "Persistent storage identity failure."
def test_methodSelfIdentity(self):
a = A()
b = B()
a.bmethod = b.bmethod
b.a = a
im_ = jelly.unjelly(jelly.jelly(b)).a.bmethod
self.assertEqual(im_.im_class, im_.im_self.__class__)
def test_persistentStorage(self):
perst = [{}, 1]
def persistentStore(obj, jel, perst=perst):
perst[1] = perst[1] + 1
perst[0][perst[1]] = obj
return str(perst[1])
def persistentLoad(pidstr, unj, perst=perst):
pid = int(pidstr)
return perst[0][pid]
a = SimpleJellyTest(1, 2)
b = SimpleJellyTest(3, 4)
c = SimpleJellyTest(5, 6)
a.b = b
a.c = c
c.b = b
jel = jelly.jelly(a, persistentStore=persistentStore)
x = jelly.unjelly(jel, persistentLoad=persistentLoad)
self.assertIdentical(x.b, x.c.b)
self.failUnless(perst[0], "persistentStore was not called.")
self.assertIdentical(x.b, a.b, "Persistent storage identity failure.")
def test_typeNewStyle(self):
"""
Test that a new style class type can be jellied and unjellied
to the original type.
"""
t = [D]
r = jelly.unjelly(jelly.jelly(t))
self.assertEqual(t, r)
def test_typeBuiltin(self):
"""
Test that a builtin type can be jellied and unjellied to the original
type.
"""
t = [str]
r = jelly.unjelly(jelly.jelly(t))
self.assertEqual(t, r)
def test_stressReferences(self):
reref = []
toplevelTuple = ({'list': reref}, reref)
reref.append(toplevelTuple)
s = jelly.jelly(toplevelTuple)
z = jelly.unjelly(s)
self.assertIs(z[0]['list'], z[1])
self.assertIs(z[0]['list'][0], z)
def test_typeOldStyle(self):
"""
Test that an old style class type can be jellied and unjellied
to the original type.
"""
t = [C]
r = jelly.unjelly(jelly.jelly(t))
self.assertEquals(t, r)
def test_stressReferences(self):
reref = []
toplevelTuple = ({"list": reref}, reref)
reref.append(toplevelTuple)
s = jelly.jelly(toplevelTuple)
z = jelly.unjelly(s)
self.assertIdentical(z[0]["list"], z[1])
self.assertIdentical(z[0]["list"][0], z)
def test_dateTime(self):
dtn = datetime.datetime.now()
dtd = datetime.datetime.now() - dtn
input = [dtn, dtd]
c = jelly.jelly(input)
output = jelly.unjelly(c)
self.assertEqual(input, output)
self.assertNotIdentical(input, output)
def testSimple(self):
"""
simplest test case
"""
assert SimpleJellyTest('a', 'b').isTheSameAs(SimpleJellyTest('a', 'b'))
a = SimpleJellyTest(1, 2)
cereal = jelly.jelly(a)
b = jelly.unjelly(cereal)
assert a.isTheSameAs(b)
def test_simple(self):
"""
Simplest test case.
"""
self.failUnless(SimpleJellyTest("a", "b").isTheSameAs(SimpleJellyTest("a", "b")))
a = SimpleJellyTest(1, 2)
cereal = jelly.jelly(a)
b = jelly.unjelly(cereal)
self.failUnless(a.isTheSameAs(b))
def testStressReferences(self):
reref = []
toplevelTuple = ({'list': reref}, reref)
reref.append(toplevelTuple)
s = jelly.jelly(toplevelTuple)
print s
z = jelly.unjelly(s)
assert z[0]['list'] is z[1]
assert z[0]['list'][0] is z
def testSimple(self):
"""
simplest test case
"""
self.failUnless(SimpleJellyTest('a', 'b').isTheSameAs(SimpleJellyTest('a', 'b')))
a = SimpleJellyTest(1, 2)
cereal = jelly.jelly(a)
b = jelly.unjelly(cereal)
self.failUnless(a.isTheSameAs(b))
def test_simple(self):
"""
Simplest test case.
"""
self.assertTrue(SimpleJellyTest('a', 'b').isTheSameAs(
SimpleJellyTest('a', 'b')))
a = SimpleJellyTest(1, 2)
cereal = jelly.jelly(a)
b = jelly.unjelly(cereal)
self.assertTrue(a.isTheSameAs(b))
def _cbGotUpdate(self, newState):
self.__dict__.update(newState)
self.isActivated = 1
# send out notifications
for listener in self._activationListeners:
listener(self)
self._activationListeners = []
self.activated()
with open(self.getFileName(), "wb") as dataFile:
dataFile.write(banana.encode(jelly.jelly(self)))
def test_newStyleClassesAttributes(self):
n = TestNode()
n1 = TestNode(n)
n11 = TestNode(n1)
n2 = TestNode(n)
# Jelly it
jel = jelly.jelly(n)
m = jelly.unjelly(jel)
# Check that it has been restored ok
self._check_newstyle(n, m)
def test_serializable(self):
"""Confirm containers can travel the wire"""
b = Container()
b.name = 'Device'
b.type = 'PseudoDevice'
b.description = "A string describing this device"
# Jelly is the low-level serializer of the twisted framework
assert jelly(b)
def test_frozenset(self):
"""
Jellying C{frozenset} instances and then unjellying the result
should produce objects which represent the values of the original
inputs.
"""
inputList = [frozenset([1, 2, 3])]
output = jelly.unjelly(jelly.jelly(inputList))
self.assertEqual(inputList, output)
self.assertNotIdentical(inputList, output)
def test_newStyle(self):
n = D()
n.x = 1
n2 = D()
n.n2 = n2
n.n3 = n2
c = jelly.jelly(n)
m = jelly.unjelly(c)
self.assertIsInstance(m, D)
self.assertIdentical(m.n2, m.n3)
def test_circleWithInvoker(self):
class DummyInvokerClass:
pass
dummyInvoker = DummyInvokerClass()
dummyInvoker.serializingPerspective = None
a0 = ClassA()
jelly.setUnjellyableForClass(ClassA, ClassA)
jelly.setUnjellyableForClass(ClassB, ClassB)
j = jelly.jelly(a0, invoker=dummyInvoker)
a1 = jelly.unjelly(j)
self.failUnlessIdentical(a1.ref.ref, a1,
"Identity not preserved in circular reference")
def testTranslateMessage(self):
cmsg = messages.Error(T_(N_("Something is really wrong. ")))
t = T_(N_("But does %s know what ?"), "Andy")
cmsg.add(t)
mmsg = jelly.unjelly(jelly.jelly(cmsg))
translator = Translator()
localedir = os.path.join(configure.localedatadir, 'locale')
translator.addLocaleDir(configure.PACKAGE, localedir)
text = translator.translate(mmsg, lang=["nl_NL"])
self.assertEquals(text, "Er is iets echt mis. Maar weet Andy wat ?")
def test_twiceUnjelliedFailureCheck(self):
"""
The object which results from jellying a L{CopyableFailure}, unjellying
the result, creating a new L{CopyableFailure} from the result of that,
jellying it, and finally unjellying the result of that has a check
method which behaves the same way as the original L{CopyableFailure}'s
check method.
"""
original = pb.CopyableFailure(ZeroDivisionError())
self.assertIdentical(
original.check(ZeroDivisionError), ZeroDivisionError)
self.assertIdentical(original.check(ArithmeticError), ArithmeticError)
copiedOnce = jelly.unjelly(
jelly.jelly(original, invoker=DummyInvoker()))
derivative = pb.CopyableFailure(copiedOnce)
copiedTwice = jelly.unjelly(
jelly.jelly(derivative, invoker=DummyInvoker()))
self.assertIdentical(
copiedTwice.check(ZeroDivisionError), ZeroDivisionError)
self.assertIdentical(
copiedTwice.check(ArithmeticError), ArithmeticError)
def testSerializeWithError(self):
wresult = messages.Result()
wresult.add(messages.Error(T_(N_("uh oh"))))
mresult = jelly.unjelly(jelly.jelly(wresult))
self.failUnless(mresult.failed)
self.assertEquals(mresult.value, None)
m = mresult.messages[0]
self.assertEquals(m.level, messages.ERROR)
text = self.translator.translate(m, lang=[
"nl_NL",
])
self.assertEquals(text, "o jeetje")
def test_unjellyable(self):
"""
Test that if Unjellyable is used to deserialize a jellied object,
state comes out right.
"""
class JellyableTestClass(jelly.Jellyable):
pass
jelly.setUnjellyableForClass(JellyableTestClass, jelly.Unjellyable)
input = JellyableTestClass()
input.attribute = 'value'
output = jelly.unjelly(jelly.jelly(input))
self.assertEqual(output.attribute, 'value')
self.assertIsInstance(output, jelly.Unjellyable)
def test_dateTime(self):
"""
Jellying L{datetime.timedelta} instances and then unjellying the result
should produce objects which represent the values of the original
inputs.
"""
dtn = datetime.datetime.now()
dtd = datetime.datetime.now() - dtn
inputList = [dtn, dtd]
c = jelly.jelly(inputList)
output = jelly.unjelly(c)
self.assertEqual(inputList, output)
self.assertIsNot(inputList, output)
def testSerializeWithWarning(self):
wresult = messages.Result()
wresult.add(messages.Warning(T_(N_("Warning"))))
wresult.succeed("I did it")
mresult = jelly.unjelly(jelly.jelly(wresult))
self.failIf(mresult.failed)
self.assertEquals(mresult.value, "I did it")
m = mresult.messages[0]
self.assertEquals(m.level, messages.WARNING)
text = self.translator.translate(
m, lang=["nl_NL", ])
self.assertEquals(text, "Waarschuwing")
def test_unjelliedFailureCheck(self):
"""
An unjellied L{CopyableFailure} has a check method which behaves the
same way as the original L{CopyableFailure}'s check method.
"""
original = pb.CopyableFailure(ZeroDivisionError())
self.assertIdentical(original.check(ZeroDivisionError),
ZeroDivisionError)
self.assertIdentical(original.check(ArithmeticError), ArithmeticError)
copied = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker()))
self.assertIdentical(copied.check(ZeroDivisionError),
ZeroDivisionError)
self.assertIdentical(copied.check(ArithmeticError), ArithmeticError)
def testIdentity(self):
"""
test to make sure that objects retain identity properly
"""
x = []
y = (x)
x.append(y)
x.append(y)
assert x[0] is x[1]
assert x[0][0] is x
s = jelly.jelly(x)
z = jelly.unjelly(s)
assert z[0] is z[1]
assert z[0][0] is z
def test_decimal(self):
"""
Jellying L{decimal.Decimal} instances and then unjellying the result
should produce objects which represent the values of the original
inputs.
"""
inputList = [decimal.Decimal('9.95'),
decimal.Decimal(0),
decimal.Decimal(123456),
decimal.Decimal('-78.901')]
c = jelly.jelly(inputList)
output = jelly.unjelly(c)
self.assertEqual(inputList, output)
self.assertIsNot(inputList, output)
def test_identity(self):
"""
Test to make sure that objects retain identity properly.
"""
x = []
y = (x)
x.append(y)
x.append(y)
self.assertIs(x[0], x[1])
self.assertIs(x[0][0], x)
s = jelly.jelly(x)
z = jelly.unjelly(s)
self.assertIs(z[0], z[1])
self.assertIs(z[0][0], z)
def test_printTracebackIncludesValue(self):
"""
When L{CopiedFailure.printTraceback} is used to print a copied failure
which was unjellied from a L{CopyableFailure} with C{unsafeTracebacks}
set to C{False}, the string representation of the exception value is
included in the output.
"""
original = pb.CopyableFailure(Exception("some reason"))
copied = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker()))
output = StringIO()
copied.printTraceback(output)
self.assertEqual(
"Traceback from remote host -- Traceback unavailable\n"
"exceptions.Exception: some reason\n", output.getvalue())
def test_lotsaTypes(self):
"""
Test for all types currently supported in jelly
"""
a = A()
jelly.unjelly(jelly.jelly(a))
jelly.unjelly(jelly.jelly(a.amethod))
items = [
afunc,
[1, 2, 3],
not bool(1),
bool(1),
"test",
20.3,
(1, 2, 3),
None,
A,
unittest,
{"a": 1},
A.amethod,
]
for i in items:
self.assertEqual(i, jelly.unjelly(jelly.jelly(i)))
def encodeObject(toEncode):
"""
Take a object and turn it into an string
"""
log.debug("encodeObject")
encoder = Banana()
encoder.connectionMade()
encoder._selectDialect("none")
strBuffer = io.StringIO()
encoder.transport = strBuffer
encoder.sendEncoded(jelly.jelly(toEncode))
return strBuffer.getvalue()
def test_newStyle(self):
"""
Test that a new style class can be jellied and unjellied with its
objects and attribute values preserved.
"""
n = D()
n.x = 1
n2 = D()
n.n2 = n2
n.n3 = n2
c = jelly.jelly(n)
m = jelly.unjelly(c)
self.assertIsInstance(m, D)
self.assertIs(m.n2, m.n3)
self.assertEqual(m.x, 1)
def testUnjellyable(self):
"""
Test that if Unjellyable is used to deserialize a jellied object,
state comes out right.
"""
class JellyableTestClass(jelly.Jellyable):
pass
jelly.setUnjellyableForClass(JellyableTestClass, jelly.Unjellyable)
input = JellyableTestClass()
input.attribute = 'value'
output = jelly.unjelly(jelly.jelly(input))
self.assertEquals(output.attribute, 'value')
self.failUnless(
isinstance(output, jelly.Unjellyable),
"Got instance of %r, not Unjellyable" % (output.__class__, ))
def test_throwExceptionIntoGenerator(self):
"""
L{pb.CopiedFailure.throwExceptionIntoGenerator} will throw a
L{RemoteError} into the given paused generator at the point where it
last yielded.
"""
original = pb.CopyableFailure(AttributeError("foo"))
copy = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker()))
exception = []
def generatorFunc():
try:
yield None
except pb.RemoteError, exc:
exception.append(exc)
else:
def test_methodsNotSelfIdentity(self):
"""
If a class change after an instance has been created, L{jelly.unjelly}
shoud raise a C{TypeError} when trying to unjelly the instance.
"""
a = A()
b = B()
c = C()
a.bmethod = c.cmethod
b.a = a
savecmethod = C.cmethod
del C.cmethod
try:
self.assertRaises(TypeError, jelly.unjelly, jelly.jelly(b))
finally:
C.cmethod = savecmethod
def testLotsaTypes(self):
"""
test for all types currently supported in jelly
"""
a = A()
# instance
jelly.unjelly(jelly.jelly(a))
a = A()
jelly.unjelly(jelly.jelly(a.amethod)) # method
jelly.unjelly(jelly.jelly(afunc)) # function
jelly.unjelly(jelly.jelly([1, 2, 3])) # list
jelly.unjelly(jelly.jelly('test')) # string
jelly.unjelly(jelly.jelly(50.3)) # float
jelly.unjelly(jelly.jelly((1, 2, 3))) # tuple
def test_referenceable(self):
"""
A L{pb.Referenceable} instance jellies to a structure which unjellies to
a L{pb.RemoteReference}. The C{RemoteReference} has a I{luid} that
matches up with the local object key in the L{pb.Broker} which sent the
L{Referenceable}.
"""
ref = pb.Referenceable()
jellyBroker = pb.Broker()
jellyBroker.makeConnection(StringTransport())
j = jelly.jelly(ref, invoker=jellyBroker)
unjellyBroker = pb.Broker()
unjellyBroker.makeConnection(StringTransport())
uj = jelly.unjelly(j, invoker=unjellyBroker)
self.assertIn(uj.luid, jellyBroker.localObjects)
def test_setState(self):
global TupleState
class TupleState:
def __init__(self, other):
self.other = other
def __getstate__(self):
return (self.other,)
def __setstate__(self, state):
self.other = state[0]
def __hash__(self):
return hash(self.other)
a = A()
t1 = TupleState(a)
t2 = TupleState(a)
t3 = TupleState((t1, t2))
d = {t1: t1, t2: t2, t3: t3, "t3": t3}
t3prime = jelly.unjelly(jelly.jelly(d))["t3"]
self.assertIs(t3prime.other[0].other, t3prime.other[1].other)
def _testSecurity(self, inputList, atom):
"""
Helper test method to test security options for a type.
@param inputList: a sample input for the type.
@type inputList: L{list}
@param atom: atom identifier for the type.
@type atom: L{str}
"""
c = jelly.jelly(inputList)
taster = jelly.SecurityOptions()
taster.allowBasicTypes()
# By default, it should succeed
jelly.unjelly(c, taster)
taster.allowedTypes.pop(atom)
# But it should raise an exception when disallowed
self.assertRaises(jelly.InsecureJelly, jelly.unjelly, c, taster)
def serialize(self,
object,
perspective=None,
method=None,
args=None,
kw=None):
"""Jelly an object according to the remote security rules for this broker.
"""
if isinstance(object, defer.Deferred):
object.addCallbacks(self.serialize,
lambda x: x,
callbackKeywords={
'perspective': perspective,
'method': method,
'args': args,
'kw': kw
})
return object
# XXX This call is NOT REENTRANT and testing for reentrancy is just
# crazy, so it likely won't be. Don't ever write methods that call the
# broker's serialize() method recursively (e.g. sending a method call
# from within a getState (this causes concurrency problems anyway so
# you really, really shouldn't do it))
# self.jellier = _NetJellier(self)
self.serializingPerspective = perspective
self.jellyMethod = method
self.jellyArgs = args
self.jellyKw = kw
try:
return jelly(object, self.security, None, self)
finally:
self.serializingPerspective = None
self.jellyMethod = None
self.jellyArgs = None
self.jellyKw = None
def save(self, statefile=None):
"""Save state as a pickled jelly to a file on disk."""
if not statefile:
if not self._statefile:
raise MissingState("Could not find a state file to load.")
statefile = self._statefile
logging.debug("Saving state to: \t'%s'" % statefile)
fh = None
try:
fh = open(statefile, 'w')
except (IOError, OSError) as error: # pragma: no cover
logging.warn("Error writing state file to '%s': %s" %
(statefile, error))
else:
try:
pickle.dump(jelly.jelly(self), fh)
except AttributeError as error:
logging.debug("Tried jellying an unjelliable object: %s" %
error.message)
if fh is not None:
fh.flush()
fh.close()
from twisted.spread.jelly import jelly, unjelly import pyfix.messages.enum.ExecType as ExecType pn = ExecType.PENDING_NEW print jelly(pn)
def test_str(self):
x = "blah"
y = jelly.unjelly(jelly.jelly(x))
self.assertEqual(x, y)
self.assertEqual(type(x), type(y))
def encode(self, data):
security = SecurityOptions()
security.allowBasicTypes()
jellyMessage = jelly(data, taster=security)
return bananaEncode(jellyMessage)
def test_newStyleClasses(self):
j = jelly.jelly(D)
uj = jelly.unjelly(D)
self.assertIdentical(D, uj)
def test_unicode(self):
x = unicode('blah')
y = jelly.unjelly(jelly.jelly(x))
self.assertEqual(x, y)
self.assertEqual(type(x), type(y))
def test_simpleCircle(self):
jelly.setUnjellyableForClass(ClassA, ClassA)
jelly.setUnjellyableForClass(ClassB, ClassB)
a = jelly.unjelly(jelly.jelly(ClassA()))
self.assertIs(a.ref.ref, a,
"Identity not preserved in circular reference")
