def test_decode(self):
pyamf.register_class(ListModel, "list-model")
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream.write(
"\x10\x00\nlist-model\x00\x07numbers\n\x00\x00"
"\x00\x05\x00@\x00\x00\x00\x00\x00\x00\x00\x00@\x10\x00\x00\x00"
"\x00\x00\x00\x00@\x18\x00\x00\x00\x00\x00\x00\x00@ \x00\x00"
"\x00\x00\x00\x00\x00@$\x00\x00\x00\x00\x00\x00\x00\x00\t"
)
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, "numbers"))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
decoder = pyamf.get_decoder(pyamf.AMF3)
decoder.stream.write("\n\x0b\x15list-model\x0fnumbers\t\x0b\x01\x04\x02\x04" "\x04\x04\x06\x04\x08\x04\n\x01")
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, "numbers"))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
def test_get_decoder(self):
from pyamf import amf0, amf3
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF0), amf0.Decoder)
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF3), amf3.Decoder)
self.assertRaises(ValueError, pyamf._get_decoder_class, 'spam')
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF0),
amf0.Decoder))
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF3),
amf3.Decoder))
self.assertRaises(ValueError, pyamf.get_decoder, 'spam')
context = amf0.Context()
decoder = pyamf.get_decoder(pyamf.AMF0,
data='123',
context=context,
strict=True)
self.assertEquals(decoder.stream.getvalue(), '123')
self.assertEquals(decoder.context, context)
self.assertTrue(decoder.strict)
context = amf3.Context()
decoder = pyamf.get_decoder(pyamf.AMF3,
data='456',
context=context,
strict=True)
self.assertEquals(decoder.stream.getvalue(), '456')
self.assertEquals(decoder.context, context)
self.assertTrue(decoder.strict)
def test_decode(self):
pyamf.register_class(ListModel, 'list-model')
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream.write(
'\x10\x00\nlist-model\x00\x07numbers\n\x00\x00'
'\x00\x05\x00@\x00\x00\x00\x00\x00\x00\x00\x00@\x10\x00\x00\x00'
'\x00\x00\x00\x00@\x18\x00\x00\x00\x00\x00\x00\x00@ \x00\x00'
'\x00\x00\x00\x00\x00@$\x00\x00\x00\x00\x00\x00\x00\x00\t')
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, 'numbers'))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
decoder = pyamf.get_decoder(pyamf.AMF3)
decoder.stream.write(
'\n\x0b\x15list-model\x0fnumbers\t\x0b\x01\x04\x02\x04'
'\x04\x04\x06\x04\x08\x04\n\x01')
decoder.stream.seek(0)
x = decoder.readElement()
self.assertTrue(isinstance(x, ListModel))
self.assertTrue(hasattr(x, 'numbers'))
self.assertEquals(x.numbers, [2, 4, 6, 8, 10])
def test_get_decoder(self):
self.assertRaises(ValueError, pyamf.get_decoder, 'spam')
decoder = pyamf.get_decoder(pyamf.AMF0, stream='123', strict=True)
self.assertEqual(decoder.stream.getvalue(), '123')
self.assertTrue(decoder.strict)
decoder = pyamf.get_decoder(pyamf.AMF3, stream='456', strict=True)
self.assertEqual(decoder.stream.getvalue(), '456')
self.assertTrue(decoder.strict)
def test_get_decoder(self):
self.assertRaises(ValueError, pyamf.get_decoder, 'spam')
decoder = pyamf.get_decoder(pyamf.AMF0, stream='123', strict=True)
self.assertEqual(decoder.stream.getvalue(), '123')
self.assertTrue(decoder.strict)
decoder = pyamf.get_decoder(pyamf.AMF3, stream='456', strict=True)
self.assertEqual(decoder.stream.getvalue(), '456')
self.assertTrue(decoder.strict)
def test_decode(self):
pyamf.register_class(PetModel, "Pet")
k = str(self.jessica.key())
bytes = (
"\x10\x00\x03Pet\x00\x04_key\x02%s%s\x00\x04type\x02\x00"
+ "\x03cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00"
+ "\x00\x00\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4"
+ "\xae\xaa\x00\x00\x00\x00\x00\x00\x12spayed_or_neutered"
+ "\x01\x00\x00\x00\t"
)
bytes = bytes % (struct.pack(">H", len(k)), k)
decoder = pyamf.get_decoder(pyamf.AMF0)
context = decoder.context
stream = decoder.stream
stream.write(bytes * 2)
stream.seek(0)
j = decoder.readElement()
alias = context.getClassAlias(PetModel)
self.assertTrue(isinstance(j, PetModel))
self.assertTrue(isinstance(alias, adapter_db.DataStoreClassAlias))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
j2 = decoder.readElement()
self.assertTrue(isinstance(j2, PetModel))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
def __init__( self ):
# Prepare the encoder and decoder
self.encoder = pyamf.get_encoder( self.encoding )
self.ostream = self.encoder.stream
self.decoder = pyamf.get_decoder( self.encoding )
self.istream = self.decoder.stream
self.ipos = 0
def test_amf0(self):
d = pyamf.get_decoder(pyamf.AMF0)
b = d.stream
b.write('\x10\x00\x03Pet\x00\x04_key\x02%s%s\x00\x04type\x02\x00\x03'
'cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00\x00'
'\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00'
'\x00\x00\x00\x00\x00\x12spayed_or_neutered\x01\x00\x00\x00\t' % (
struct.pack('>H', len(self.key)), self.key))
b.seek(0)
x = d.readElement()
self.assertTrue(isinstance(x, PetExpando))
self.assertEquals(x.__class__, PetExpando)
self.assertEquals(x.type, self.jessica.type)
self.assertEquals(x.weight_in_pounds, self.jessica.weight_in_pounds)
self.assertEquals(x.birthdate, datetime.date(1986, 10, 2))
self.assertEquals(x.spayed_or_neutered, self.jessica.spayed_or_neutered)
# now check db.Expando internals
self.assertEquals(x.key(), self.jessica.key())
self.assertEquals(x.kind(), self.jessica.kind())
self.assertEquals(x.parent(), self.jessica.parent())
self.assertEquals(x.parent_key(), self.jessica.parent_key())
self.assertTrue(x.is_saved())
def test_amf3(self):
d = pyamf.get_decoder(pyamf.AMF3)
b = d.stream
b.write(
"\n\x0b\x07Pet\tname\x06\x0fJessica\t_key\x06%s%s\x13birthdate"
"\x08\x01B^\xc4\xae\xaa\x00\x00\x00!weight_in_pounds\x04\x05\x07"
"foo\x06\x07bar\ttype\x06\x07cat%%spayed_or_neutered\x02\x01"
% (amf3._encode_int(len(self.key) << 1 | amf3.REFERENCE_BIT), self.key)
)
b.seek(0)
x = d.readElement()
self.assertTrue(isinstance(x, PetExpando))
self.assertEquals(x.__class__, PetExpando)
self.assertEquals(x.type, self.jessica.type)
self.assertEquals(x.weight_in_pounds, self.jessica.weight_in_pounds)
self.assertEquals(x.birthdate, datetime.date(1986, 10, 2))
self.assertEquals(x.spayed_or_neutered, self.jessica.spayed_or_neutered)
# now check db.Expando internals
self.assertEquals(x.key(), self.jessica.key())
self.assertEquals(x.kind(), self.jessica.kind())
self.assertEquals(x.parent(), self.jessica.parent())
self.assertEquals(x.parent_key(), self.jessica.parent_key())
self.assertTrue(x.is_saved())
def test_amf0(self):
d = pyamf.get_decoder(pyamf.AMF0)
b = d.stream
b.write(
"\x10\x00\x03Pet\x00\x04_key\x02%s%s\x00\x04type\x02\x00\x03"
"cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00\x00\x00"
"\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4\xae\xaa\x00"
"\x00\x00\x00\x00\x00\x12spayed_or_neutered\x01\x00\x00\x00\t"
% (struct.pack(">H", len(self.key)), self.key)
)
b.seek(0)
x = d.readElement()
self.assertTrue(isinstance(x, PetExpando))
self.assertEquals(x.__class__, PetExpando)
self.assertEquals(x.type, self.jessica.type)
self.assertEquals(x.weight_in_pounds, self.jessica.weight_in_pounds)
self.assertEquals(x.birthdate, datetime.date(1986, 10, 2))
self.assertEquals(x.spayed_or_neutered, self.jessica.spayed_or_neutered)
# now check db.Expando internals
self.assertEquals(x.key(), self.jessica.key())
self.assertEquals(x.kind(), self.jessica.kind())
self.assertEquals(x.parent(), self.jessica.parent())
self.assertEquals(x.parent_key(), self.jessica.parent_key())
self.assertTrue(x.is_saved())
def test_decode(self):
pyamf.register_class(PetModel, 'Pet')
k = str(self.jessica.key())
bytes = '\x10\x00\x03Pet\x00\x04_key\x02%s%s\x00\x04type\x02\x00' + \
'\x03cat\x00\x10weight_in_pounds\x00@\x14\x00\x00\x00\x00\x00' + \
'\x00\x00\x04name\x02\x00\x07Jessica\x00\tbirthdate\x0bB^\xc4' + \
'\xae\xaa\x00\x00\x00\x00\x00\x00\x12spayed_or_neutered' + \
'\x01\x00\x00\x00\t'
bytes = bytes % (struct.pack('>H', len(k)), k)
decoder = pyamf.get_decoder(pyamf.AMF0)
context = decoder.context
stream = decoder.stream
stream.write(bytes * 2)
stream.seek(0)
j = decoder.readElement()
alias = context.getClassAlias(PetModel)
self.assertTrue(isinstance(j, PetModel))
self.assertTrue(isinstance(alias, adapter_db.DataStoreClassAlias))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
j2 = decoder.readElement()
self.assertTrue(isinstance(j2, PetModel))
self.assertEquals(context.gae_objects, {PetModel: {k: j}})
def test_amf3(self):
d = pyamf.get_decoder(pyamf.AMF3)
b = d.stream
b.write('\n\x0b\x07Pet\tname\x06\x0fJessica\t_key\x06%s%s\x13birthdate'
'\x08\x01B^\xc4\xae\xaa\x00\x00\x00!weight_in_pounds\x04\x05\x07'
'foo\x06\x07bar\ttype\x06\x07cat%%spayed_or_neutered\x02\x01' % (
amf3.encode_int(len(self.key) << 1 | amf3.REFERENCE_BIT), self.key))
b.seek(0)
x = d.readElement()
self.assertTrue(isinstance(x, PetExpando))
self.assertEquals(x.__class__, PetExpando)
self.assertEquals(x.type, self.jessica.type)
self.assertEquals(x.weight_in_pounds, self.jessica.weight_in_pounds)
self.assertEquals(x.birthdate, datetime.date(1986, 10, 2))
self.assertEquals(x.spayed_or_neutered, self.jessica.spayed_or_neutered)
# now check db.Expando internals
self.assertEquals(x.key(), self.jessica.key())
self.assertEquals(x.kind(), self.jessica.kind())
self.assertEquals(x.parent(), self.jessica.parent())
self.assertEquals(x.parent_key(), self.jessica.parent_key())
self.assertTrue(x.is_saved())
def send(self, message):
self.sends.append(message)
# tell server we started listening
logging.debug('send: request: %s' % message.__repr__())
encoder = pyamf.get_encoder(object_encoding)
encoder.writeElement(message)
message = encoder.stream.getvalue()
encoder.stream.truncate()
logging.debug('send: encoded request: %s' % message.__repr__())
send_log = encoder.stream.tell().__repr__() \
+ encoder.stream.__repr__()
logging.debug('send; ' + send_log)
decoder = pyamf.get_decoder(object_encoding, message)
#if not isinstance(stream, util.BufferedByteStream):
# stream = util.BufferedByteStream(stream)
logging.debug('send: '
+ decoder.stream.tell().__repr__()
+ decoder.stream.__repr__())
data = decoder.readElement()
logging.debug('send: decoded %s' % data.__repr__())
try:
#total_sent = 0
#while total_sent < len(message):
sent = self.sock.send(message)
if sent == 0:
raise RuntimeError, \
"socket connection broken"
# total_sent += sent
except socket.error, e:
raise Exception("Can't connect: %s" % e[1])
def listen(envoy):
response = ''
# http://bytes.com/topic/python/answers/22953-how-catch-socket-timeout
try:
chunk = envoy.recv(1024)
if '' == chunk:
error_message = 'RuntimeError socket connection broken'
logging.error('listen', error_message)
response += chunk
except socket.timeout:
logging.error('listen timeout')
logging.error('listen %s' % response.__repr__())
return 'timeout'
except socket.error:
import sys
error_number, error_string = sys.exc_info()[:2]
error_message = 'socket error %i: "%s"' \
% (error_number, error_string)
logging.error('listen', error_message)
return error_message
decoder = pyamf.get_decoder(object_encoding, response)
#if not isinstance(stream, util.BufferedByteStream):
# stream = util.BufferedByteStream(stream)
logging.debug('listen: response: ' + response.__repr__())
logging.debug('listen: stream: ' + decoder.stream.__repr__())
data = decoder.readElement()
logging.debug('listen decoded %s' % data.__repr__())
return data
def _amf3_decoder(self):
decoder = getattr(self, "__amf3_decoder", None)
if not decoder:
decoder = pyamf.get_decoder(pyamf.AMF3, stream=self.stream, timezone_offset=self.timezone_offset)
self.__amf3_decoder = decoder
return decoder
def decode(self, buf):
"""
Decode a notification message.
"""
decoder = pyamf.get_decoder(pyamf.AMF0, stream=buf)
self.name = decoder.next()
self.argv = [x for x in decoder]
def decode(self, buf):
"""
Decode a notification message.
"""
decoder = pyamf.get_decoder(pyamf.AMF0, stream=buf)
self.name = decoder.next()
self.argv = [x for x in decoder]
def decode(self, buf):
"""
Decode a notification message.
"""
decoder = pyamf.get_decoder(self.encoding, stream=buf)
self.name = decoder.next()
self.id = decoder.next()
self.argv = list(decoder)
def test_pure_decoder(self):
"""
With `use_ext=False` specified, the extension must NOT be returned.
"""
from pyamf import amf3
decoder = pyamf.get_decoder(pyamf.AMF3, use_ext=False)
self.assertIsInstance(decoder, amf3.Decoder)
def test_pure_decoder(self):
"""
With `use_ext=False` specified, the extension must NOT be returned.
"""
from pyamf import amf3
decoder = pyamf.get_decoder(pyamf.AMF3, use_ext=False)
self.assertIsInstance(decoder, amf3.Decoder)
def test_encode_decode_transient(self):
user = self._build_obj()
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(user)
encoded = encoder.stream.getvalue()
decoded = pyamf.get_decoder(pyamf.AMF3, encoded).readElement()
self._test_obj(user, decoded)
def _amf3_decoder(self):
decoder = getattr(self, '__amf3_decoder', None)
if not decoder:
decoder = pyamf.get_decoder(pyamf.AMF3, stream=self.stream,
timezone_offset=self.timezone_offset)
self.__amf3_decoder = decoder
return decoder
def decode(self, buf):
"""
Decode a notification message.
"""
decoder = pyamf.get_decoder(self.encoding, stream=buf)
self.name = decoder.next()
self.id = decoder.next()
self.argv = list(decoder)
def test_encode(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream = encoder.stream
try:
raise TypeError, "unknown type"
except TypeError, e:
encoder.writeElement(amf0.build_fault(*sys.exc_info()))
def test_encode(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream = encoder.stream
try:
raise TypeError("Unknown type")
except TypeError, e:
encoder.writeElement(amf0.build_fault(*sys.exc_info()))
def decode(stream, strict=True):
"""
Decodes a SOL stream. L{strict} mode ensures that the sol stream is as spec
compatible as possible.
@return: A C{tuple} containing the C{root_name} and a C{dict} of name,
value pairs.
"""
if not isinstance(stream, util.BufferedByteStream):
stream = util.BufferedByteStream(stream)
# read the version
version = stream.read(2)
if version != HEADER_VERSION:
raise pyamf.DecodeError('Unknown SOL version in header')
# read the length
length = stream.read_ulong()
if strict and stream.remaining() != length:
raise pyamf.DecodeError('Inconsistent stream header length')
# read the signature
signature = stream.read(10)
if signature != HEADER_SIGNATURE:
raise pyamf.DecodeError('Invalid signature')
length = stream.read_ushort()
root_name = stream.read_utf8_string(length)
# read padding
if stream.read(3) != PADDING_BYTE * 3:
raise pyamf.DecodeError('Invalid padding read')
decoder = pyamf.get_decoder(stream.read_uchar())
decoder.stream = stream
values = {}
while True:
if stream.at_eof():
break
name = decoder.readString()
value = decoder.readElement()
# read the padding
t = stream.read(1)
while t != PADDING_BYTE:
# raise pyamf.DecodeError('Missing padding byte')
sys.stderr.write('Bad padding byte: 0x02%x\n' % ord(t))
t = stream.read(1)
values[name] = value
return (root_name, values)
def setUp(self):
BaseTestCase.setUp(self)
class FloatModel(db.Model):
f = db.FloatProperty()
self.klass = FloatModel
self.f = FloatModel()
self.alias = adapter.DataStoreClassAlias(self.klass, None)
self.decoder = pyamf.get_decoder(pyamf.AMF3)
def setUp(self):
BaseTestCase.setUp(self)
self.alias = adapter.DataStoreClassAlias(models.PetModel, "foo.bar")
self.jessica = models.PetModel(name="Jessica", type="cat")
self.jessica_expando = models.PetExpando(name="Jessica", type="cat")
self.jessica_expando.foo = "bar"
self.decoder = pyamf.get_decoder(pyamf.AMF3)
def test_none(self):
pyamf.register_class(ListModel, "list-model")
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream.write("\x10\x00\nlist-model\x00\x07numbers\x05\x00\x00\t")
decoder.stream.seek(0)
x = decoder.readElement()
self.assertEquals(x.numbers, [])
def setUp(self):
BaseTestCase.setUp(self)
class FloatModel(db.Model):
f = db.FloatProperty()
self.klass = FloatModel
self.f = FloatModel()
self.alias = adapter.DataStoreClassAlias(self.klass, None)
self.decoder = pyamf.get_decoder(pyamf.AMF3)
def setUp(self):
BaseTestCase.setUp(self)
self.alias = adapter.DataStoreClassAlias(models.PetModel, 'foo.bar')
self.jessica = models.PetModel(name='Jessica', type='cat')
self.jessica_expando = models.PetExpando(name='Jessica', type='cat')
self.jessica_expando.foo = 'bar'
self.decoder = pyamf.get_decoder(pyamf.AMF3)
def getAMF3Decoder(self, amf0_decoder):
decoder = self.extra.get('amf3_decoder', None)
if decoder:
return decoder
decoder = pyamf.get_decoder(pyamf.AMF3, stream=amf0_decoder.stream,
timezone_offset=amf0_decoder.timezone_offset)
self.extra['amf3_decoder'] = decoder
return decoder
def getAMF3Decoder(self, amf0_decoder):
decoder = self.extra.get('amf3_decoder', None)
if decoder:
return decoder
decoder = pyamf.get_decoder(pyamf.AMF3, stream=amf0_decoder.stream,
timezone_offset=amf0_decoder.timezone_offset)
self.extra['amf3_decoder'] = decoder
return decoder
def test_none(self):
pyamf.register_class(ListModel, 'list-model')
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream.write(
'\x10\x00\nlist-model\x00\x07numbers\x05\x00\x00\t')
decoder.stream.seek(0)
x = decoder.readElement()
self.assertEquals(x.numbers, [])
def test_get_decoder(self):
from pyamf import amf0, amf3
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF0), amf0.Decoder)
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF3), amf3.Decoder)
self.assertRaises(ValueError, pyamf._get_decoder_class, 'spam')
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF0), amf0.Decoder))
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF3), amf3.Decoder))
self.assertRaises(ValueError, pyamf.get_decoder, 'spam')
context = amf0.Context()
decoder = pyamf.get_decoder(pyamf.AMF0, data='123', context=context)
self.assertEquals(decoder.stream.getvalue(), '123')
self.assertEquals(decoder.context, context)
context = amf3.Context()
decoder = pyamf.get_decoder(pyamf.AMF3, data='456', context=context)
self.assertEquals(decoder.stream.getvalue(), '456')
self.assertEquals(decoder.context, context)
def test_ext_decoder(self):
"""
With `use_ext=True` specified, the extension must be returned.
"""
try:
from cpyamf import amf3
except ImportError:
self.skipTest('amf3 extension not available')
decoder = pyamf.get_decoder(pyamf.AMF3, use_ext=True)
self.assertIsInstance(decoder, amf3.Decoder)
def test_default_decoder(self):
"""
If the extension is available, it must be returned by default.
"""
try:
from cpyamf import amf3
except ImportError:
from pyamf import amf3
decoder = pyamf.get_decoder(pyamf.AMF3)
self.assertIsInstance(decoder, amf3.Decoder)
def test_default_decoder(self):
"""
If the extension is available, it must be returned by default.
"""
try:
from cpyamf import amf3
except ImportError:
from pyamf import amf3
decoder = pyamf.get_decoder(pyamf.AMF3)
self.assertIsInstance(decoder, amf3.Decoder)
def test_encode_decode_persistent(self):
user = self._build_obj()
self.session.save(user)
self.session.commit()
self.session.refresh(user)
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(user)
encoded = encoder.stream.getvalue()
decoded = pyamf.get_decoder(pyamf.AMF3, encoded).readElement()
self._test_obj(user, decoded)
def parse_on_metadata_tag(tag_bytes):
try:
stream = pyamf.util.BufferedByteStream(tag_bytes)
decoder = pyamf.get_decoder(pyamf.AMF0, stream)
tag_name = decoder.readElement()
if tag_name != 'onMetaData':
return {}
return decoder.readElement()
except pyamf.BaseError:
logger.exception('Failed to parse FLV metadata')
return {}
def test_ext_decoder(self):
"""
With `use_ext=True` specified, the extension must be returned.
"""
try:
from cpyamf import amf3
except ImportError:
self.skipTest('amf3 extension not available')
decoder = pyamf.get_decoder(pyamf.AMF3, use_ext=True)
self.assertIsInstance(decoder, amf3.Decoder)
def test_get_decoder(self):
from pyamf import amf0, amf3
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF0), amf0.Decoder)
self.assertEquals(pyamf._get_decoder_class(pyamf.AMF3), amf3.Decoder)
self.assertRaises(ValueError, pyamf._get_decoder_class, "spam")
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF0), amf0.Decoder))
self.assertTrue(isinstance(pyamf.get_decoder(pyamf.AMF3), amf3.Decoder))
self.assertRaises(ValueError, pyamf.get_decoder, "spam")
context = amf0.Context()
decoder = pyamf.get_decoder(pyamf.AMF0, stream="123", context=context, strict=True)
self.assertEquals(decoder.stream.getvalue(), "123")
self.assertEquals(decoder.context, context)
self.assertTrue(decoder.strict)
context = amf3.Context()
decoder = pyamf.get_decoder(pyamf.AMF3, stream="456", context=context, strict=True)
self.assertEquals(decoder.stream.getvalue(), "456")
self.assertEquals(decoder.context, context)
self.assertTrue(decoder.strict)
def decode(self, raw_obj, amf3=False):
if amf3 is True:
amf_type = pyamf.AMF3
else:
amf_type = pyamf.AMF0
context = pyamf.get_context(amf_type)
decoder = pyamf.get_decoder(amf_type, raw_obj, context=context)
obj = decoder.readElement()
if amfast.log_raw:
self.logRaw('rawDecodeObject', raw_obj)
return obj
def decode(self, raw_obj, amf3=False):
if amf3 is True:
amf_type = pyamf.AMF3
else:
amf_type = pyamf.AMF0
context = pyamf.get_context(amf_type)
decoder = pyamf.get_decoder(amf_type, raw_obj, context=context)
obj = decoder.readElement()
if amfast.log_raw:
self.logRaw('rawDecodeObject', raw_obj)
return obj
def setUp(self):
BaseTestCase.setUp(self)
self.alias = adapter.DataStoreClassAlias(
models.PetModel, 'foo.bar'
)
self.jessica = models.PetModel(name='Jessica', type='cat')
self.jessica_expando = models.PetExpando(
name='Jessica', type='cat'
)
self.jessica_expando.foo = 'bar'
self.decoder = pyamf.get_decoder(pyamf.AMF3)
def test_no_pk(self):
"""
Ensure that Models without a primary key are correctly serialized.
See #691.
"""
from django.db import models
class NotSaved(models.Model):
name = models.CharField(max_length=100)
instances = [NotSaved(name="a"), NotSaved(name="b")]
encoded = pyamf.encode(instances, encoding=pyamf.AMF3).getvalue()
decoded = pyamf.get_decoder(pyamf.AMF3, encoded).readElement()
self.assertEquals(decoded[0]['name'], 'a')
self.assertEquals(decoded[1]['name'], 'b')
def test_lazy_load_attributes(self):
user = self._build_obj()
user.lazy_loaded.append(LazyLoaded())
self.session.save(user)
self.session.commit()
self.session.clear()
user = self.session.query(User).first()
encoder = pyamf.get_encoder(pyamf.AMF3)
encoder.writeElement(user)
encoded = encoder.stream.getvalue()
decoded = pyamf.get_decoder(pyamf.AMF3, encoded).readElement()
self.assertFalse(decoded.__dict__.has_key('lazy_loaded'))
def decode(self, buf):
"""
Decode a notification message.
"""
decoder = pyamf.get_decoder(pyamf.AMF0, stream=buf)
self.name = decoder.next()
self.argv = []
while 1:
try:
x = decoder.next()
self.argv.append(x)
except StopIteration:
break
except UnicodeDecodeError:
break
def decode_object(amf_data):
'''Is the object limited to a size less than about 40 kB to 90 kB?'''
raw_text = represent(amf_data)
raw = 'decode_object: amf_data: %s' % raw_text
logging.debug(raw)
decoder = pyamf.get_decoder(object_encoding, amf_data)
## logging.debug('decode_object: stream: ' + represent(decoder.stream))
message = None
try:
# XXX Sometimes ASObject whose string representation is 68 kB
# returns an IOError.
message = decoder.readElement()
except IOError:
logging.error(raw)
logging.error('decode_object IOError')
# XXX Will another dataReceived callback occur?
return IOError
except pyamf.EOStream:
logging.error(raw)
end_of_stream = 'decode_object: EOStream'
logging.error(end_of_stream)
return IOError
except pyamf.DecodeError:
logging.error(raw)
decode_error = 'decode_object: DecodeError'
logging.error(decode_error)
return IOError
except:
logging.error(raw)
error = 'decode_object: Error'
logging.error(error)
raise
if message is not None:
decoded = 'decode_object: decoded %s' % represent(message)
logging.debug(decoded)
if pyamf.ASObject != type(message) and dict != type(message):
not_an_object = 'decode_object: i was expecting simple object: %s' \
% represent(message)
logging.error(not_an_object)
return IOError
else:
no_message = 'decode_object: no message? "%s"' % represent(message)
logging.warn(no_message)
return message
def readAMF3(self):
"""
Read AMF3 elements from the data stream.
@rtype: C{mixed}
@return: The AMF3 element read from the stream
"""
if not hasattr(self.context, 'amf3_context'):
self.context.amf3_context = pyamf.get_context(pyamf.AMF3,
exceptions=False)
if not hasattr(self.context, 'amf3_decoder'):
self.context.amf3_decoder = pyamf.get_decoder(
pyamf.AMF3, self.stream, self.context.amf3_context)
decoder = self.context.amf3_decoder
element = decoder.readElement()
self.context.addAMF3Object(element)
return element
def test_encode(self):
encoder = pyamf.get_encoder(pyamf.AMF0)
decoder = pyamf.get_decoder(pyamf.AMF0)
decoder.stream = encoder.stream
try:
raise TypeError("Unknown type")
except TypeError:
encoder.writeElement(amf0.build_fault(*sys.exc_info()))
buffer = encoder.stream
buffer.seek(0, 0)
fault = decoder.readElement()
old_fault = amf0.build_fault(*sys.exc_info())
self.assertEqual(fault.level, old_fault.level)
self.assertEqual(fault.type, old_fault.type)
self.assertEqual(fault.code, old_fault.code)
self.assertEqual(fault.details, old_fault.details)
self.assertEqual(fault.description, old_fault.description)
def decode(stream, strict=False, logger=None, timezone_offset=None):
"""
Decodes the incoming stream as a remoting message.
@type stream: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
@param strict: Enforce strict decoding. Default is C{False}.
@type strict: C{boolean}
@param logger: Used to log interesting events whilst decoding a remoting
message.
@type logger: U{logging.Logger<http://
docs.python.org/library/logging.html#loggers>}
@param timezone_offset: The difference between the current timezone and
UTC. Date/times should always be handled in UTC to avoid confusion but
this is required for legacy systems.
@type timezone_offset: U{datetime.datetime.timedelta<http://
docs.python.org/library/datetime.html#datetime.timedelta>}
@return: Message L{envelope<Envelope>}.
@rtype: L{Envelope}
"""
if not isinstance(stream, util.BufferedByteStream):
stream = util.BufferedByteStream(stream)
msg = Envelope()
msg.amfVersion = stream.read_ushort()
# see http://osflash.org/documentation/amf/envelopes/remoting#preamble
# why we are doing this...
if msg.amfVersion > 0x09:
raise pyamf.DecodeError(
"Malformed stream (amfVersion=%d)" % (
msg.amfVersion,
)
)
decoder = pyamf.get_decoder(
pyamf.AMF0,
stream,
strict=strict,
timezone_offset=timezone_offset
)
context = decoder.context
decoder.use_amf3 = msg.amfVersion == pyamf.AMF3
header_count = stream.read_ushort()
for i in xrange(header_count):
name, required, data = _read_header(stream, decoder, strict)
msg.headers[name] = data
if required:
msg.headers.set_required(name)
body_count = stream.read_short()
for i in xrange(body_count):
context.clear()
target, payload = _read_body(stream, decoder, strict, logger)
msg[target] = payload
if strict and stream.remaining() > 0:
raise RuntimeError("Unable to fully consume the buffer")
return msg
def setUp(self):
self.decoder = pyamf.get_decoder(encoding=self.amf_type)
self.buf = self.decoder.stream
self.context = self.decoder.context
def setUp(self):
self.decoder = pyamf.get_decoder(pyamf.AMF3)
self.buffer = self.decoder.stream
def setUp(self):
BaseCodecMixIn.setUp(self)
self.decoder = pyamf.get_decoder(
self.amf_version, data=self.stream, context=self.context)
def decode(stream,
context=None,
strict=False,
logger=None,
timezone_offset=None):
"""
Decodes the incoming stream as a remoting message.
@param stream: AMF data.
@type stream: L{BufferedByteStream<pyamf.util.BufferedByteStream>}
@param context: Context.
@type context: L{amf0.Context<pyamf.amf0.Context>} or
L{amf3.Context<pyamf.amf3.Context>}
@param strict: Enforce strict decoding. Default is C{False}.
@type strict: C{bool}
@param logger: Used to log interesting events whilst decoding a remoting
message.
@type logger: A L{logging.Logger} instance or C{None}.
@param timezone_offset: The difference between the current timezone and
UTC. Date/times should always be handled in UTC to avoid confusion but
this is required for legacy systems.
@type timezone_offset: L{datetime.timedelta}
@raise DecodeError: Malformed stream.
@raise RuntimeError: Decoder is unable to fully consume the
stream buffer.
@return: Message envelope.
@rtype: L{Envelope}
"""
if not isinstance(stream, util.BufferedByteStream):
stream = util.BufferedByteStream(stream)
if logger is not None:
logger.debug('remoting.decode start')
msg = Envelope()
msg.amfVersion = stream.read_uchar()
# see http://osflash.org/documentation/amf/envelopes/remoting#preamble
# why we are doing this...
if msg.amfVersion > 0x09:
raise pyamf.DecodeError("Malformed stream (amfVersion=%d)" %
msg.amfVersion)
if context is None:
context = pyamf.get_context(pyamf.AMF0, exceptions=False)
decoder = pyamf.get_decoder(pyamf.AMF0,
stream,
context=context,
strict=strict,
timezone_offset=timezone_offset)
msg.clientType = stream.read_uchar()
header_count = stream.read_ushort()
for i in xrange(header_count):
name, required, data = _read_header(stream, decoder, strict)
msg.headers[name] = data
if required:
msg.headers.set_required(name)
body_count = stream.read_short()
for i in range(body_count):
context.clear()
target, payload = _read_body(stream, decoder, strict, logger)
msg[target] = payload
if strict and stream.remaining() > 0:
raise RuntimeError("Unable to fully consume the buffer")
if logger is not None:
logger.debug('remoting.decode end')
return msg
