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_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(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_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 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) 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 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_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_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 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