Changeset 1100

Timestamp:

03/01/08 21:38:44 (9 months ago)

Author:

nick

Message:

Merging forward source:pyamf/trunk r1088:r1099

Location:

pyamf/branches/logging-173/pyamf

Files:

• __init__.py (modified) (2 diffs)
• amf0.py (modified) (6 diffs)
• amf3.py (modified) (7 diffs)
• remoting/__init__.py (modified) (8 diffs)
• tests/gateway/test_twisted.py (modified) (3 diffs)
• tests/test_amf0.py (modified) (3 diffs)
• tests/test_amf3.py (modified) (3 diffs)
• util.py (modified) (1 diff)

pyamf/branches/logging-173/pyamf/__init__.py

@@ -191 +191 @@
     """
     This class represents a Flash Actionscript Object (typed or untyped).
-    
+
     I supply a C{__builtin__.dict} interface to support get/setattr calls.
     """
@@ -362 +362 @@
         @return: Instance of C{self.klass}.
         """
+        if hasattr(self.klass, '__setstate__') or hasattr(self.klass, '__getstate__'):
+            if type(self.klass) is types.TypeType:  # new-style class
+                return self.klass.__new__(self.klass)
+            elif type(self.klass) is types.ClassType: # classic class
+                return util.make_classic_instance(self.klass)
+
+                raise TypeError, 'invalid class type %r' % self.klass
+
         return self.klass(*args, **kwargs)
 

pyamf/branches/logging-173/pyamf/amf0.py

@@ -20 +20 @@
 """
 
-import datetime, types
+import datetime, types, logging
 
 import pyamf
 from pyamf import util
+
+logger = logging.getLogger(__name__)
 
 class ASTypes:
@@ -51 +53 @@
     #: 1 single byte, C{0×06} indicates null.
     UNDEFINED   = 0x06
-    #: When an ActionScript object refers to itself, such C{this.self = this}, or
-    #: when objects are repeated within the same scope (for example, as the two
-    #: parameters of the same function called), a code of C{0×07} and an C{int},
-    #: the reference number, are written.
+    #: When an ActionScript object refers to itself, such C{this.self = this},
+    #: or when objects are repeated within the same scope (for example, as the
+    #: two parameters of the same function called), a code of C{0×07} and an
+    #: C{int}, the reference number, are written.
     REFERENCE   = 0x07
     #: A MixedArray is indicated by code C{0×08}, then a Long representing the
-    #: highest numeric index in the array, or 0 if there are none or they are all
-    #: negative. After that follow the elements in key : value pairs.
+    #: highest numeric index in the array, or 0 if there are none or they are
+    #: all negative. After that follow the elements in key : value pairs.
     MIXEDARRAY  = 0x08
     #: @see: L{OBJECT}
     OBJECTTERM  = 0x09
     #: An array is indicated by C{0x0A}, then a Long for array length, then the
-    #: array elements themselves. Arrays are always sparse; values for inexistant
-    #: keys are set to null (C{0×06}) to maintain sparsity.
+    #: array elements themselves. Arrays are always sparse; values for
+    #: inexistant keys are set to null (C{0×06}) to maintain sparsity.
     ARRAY       = 0x0a
     #: Date is represented as C{00x0B}, then a double, then an C{int}. The double
@@ -348 +350 @@
             attrs = alias.getAttrs(obj)
 
-            if attrs is None:
-                alias = None
-
         key = self.readString()
 
         ot = chr(ASTypes.OBJECTTERM)
+        obj_attrs = dict()
 
         while self.stream.peek() != ot:
-            if alias:
-                if key not in attrs:
-                    self.readElement()
-                    key = self.readString()
-                    continue
-
-            if isinstance(obj, (list, dict)):
-                obj[key] = self.readElement()
-            else:
-                value = self.readElement()
-
-                try:
-                    setattr(obj, key, value)
-                except AttributeError:
-                    obj.__dict__[key] = value
-
+            obj_attrs[key] = self.readElement()
             key = self.readString()
 
         # discard the end marker (ASTypes.OBJECTTERM)
         self.stream.read(len(ot))
+
+        if attrs is None:
+            attrs = obj_attrs.keys()
+
+        if alias:
+            if hasattr(obj, '__setstate__'):
+                obj.__setstate__(obj_attrs)
+
+                return
+
+            for key in filter(lambda x: x in attrs, obj_attrs.keys()):
+                obj.__setattr__(key, obj_attrs[key])
+        else:
+            f = obj.__setattr__
+
+            if isinstance(obj, (list, dict)):
+                f = obj.__setitem__
+
+            for key, value in obj_attrs.iteritems():
+                f(key, value)
+
+        return
 
     def readObject(self):
@@ -600 +607 @@
         @param  writeType: Write data type.
         """
-        if not isinstance(s, basestring):
-            s = str(s)
-
-        if not isinstance(s, unicode):
-            s = unicode(s)
-
-        s = s.encode('utf8')
+        if isinstance(s, unicode):
+            s = s.encode('utf8')
+        elif not isinstance(s, basestring):
+            s = unicode(s).encode('utf8')
 
         if len(s) > 0xffff:
@@ -707 +711 @@
                 self.writeString(alias.alias, False)
 
-        if alias is not None:
+        if hasattr(o, '__getstate__'):
+            for key, value in o.__getstate__().iteritems():
+                self.writeString(key, False)
+                self.writeElement(value)
+        elif alias is not None:
             it = alias.getAttrs(o)
 
@@ -716 +724 @@
             for key in it:
                 self.writeString(key, False)
-                self.writeElement(util.get_attr(o, key))
+                self.writeElement(getattr(o, key))
         elif hasattr(o, 'iteritems'):
             for k, v in o.iteritems():

pyamf/branches/logging-173/pyamf/amf3.py

@@ -622 +622 @@
         attrs = None
 
-        if hasattr(obj, 'keys'):
+        if hasattr(obj, '__getstate__'):
+            attrs = set([unicode(k) for k in obj.__getstate__()])
+        elif hasattr(obj, 'keys'):
             attrs = set([unicode(k) for k in obj.keys()])
         elif hasattr(obj, 'iteritems'):
@@ -1094 +1096 @@
             raise pyamf.EncodeError, "Decoding an object in amf3 tagged as amf0 only is not allowed"
 
-        klass = class_def.getClass()
-
-        obj = klass()
+        if class_def.alias:
+            obj = class_def.alias()
+        else:
+            klass = class_def.getClass()
+            obj = klass()
+
+        obj_attrs = pyamf.ASObject()
         self.context.addObject(obj)
 
@@ -1102 +1108 @@
             obj.__readamf__(DataInput(self))
         elif class_def.encoding == ObjectEncoding.DYNAMIC:
-            readStatic(class_ref, class_def, obj, num_attrs)
-            readDynamic(class_ref, class_def, obj)
+            readStatic(class_ref, class_def, obj_attrs, num_attrs)
+            readDynamic(class_ref, class_def, obj_attrs)
         elif class_def.encoding == ObjectEncoding.STATIC:
-            readStatic(class_ref, class_def, obj, num_attrs)
+            readStatic(class_ref, class_def, obj_attrs, num_attrs)
         else:
             raise pyamf.DecodeError, "Unknown object encoding"
+
+        if hasattr(obj, '__setstate__'):
+            obj.__setstate__(obj_attrs)
+        else:
+            for k, v in obj_attrs.iteritems():
+                obj.__setattr__(k, v)
 
         return obj
@@ -1325 +1337 @@
         """
         if not isinstance(n, basestring):
-            raise TypeError, "str or unicode expected"
-
-        if not isinstance(n, unicode):
-            try:
-                n = unicode(n)
-            except UnicodeError:
-                raise pyamf.EncodeError, "error converting str to unicode"
-
-        if len(n) == 0:
+            bytes = unicode(n).encode('utf8')
+            n = bytes
+        elif isinstance(n, unicode):
+            bytes = n.encode('utf8')
+        else:
+            bytes = n
+
+        if len(bytes) == 0:
             self._writeInteger(REFERENCE_BIT)
 
@@ -1347 +1358 @@
                 self.context.addString(n)
 
-        bytes = n.encode('utf8')
         self._writeInteger((len(bytes) << 1) | REFERENCE_BIT)
-
         self.stream.write(bytes)
 
@@ -1555 +1564 @@
                 [self._writeString(attr) for attr in attrs]
 
-            [self.writeElement(util.get_attr(obj, attr)) for attr in attrs]
+            [self.writeElement(obj[attr]) for attr in attrs]
 
         self.writeType(ASTypes.OBJECT)
@@ -1591 +1600 @@
             class_def = self._getClassDefinition(obj)
 
+        if hasattr(obj, '__getstate__'):
+            obj_attrs = obj.__getstate__()
+        elif hasattr(obj, 'iteritems'):
+            obj_attrs = {}
+
+            for k, v in obj.iteritems():
+                obj_attrs[k] = v
+        elif hasattr(obj, '__dict__'):
+            obj_attrs = obj.__dict__
+
         if class_def.encoding in (ObjectEncoding.EXTERNAL, ObjectEncoding.PROXY):
             obj.__writeamf__(DataOutput(self))
-        elif class_def.encoding == ObjectEncoding.DYNAMIC:
+        else:
             static_attrs, dynamic_attrs = class_def.getAttrs(obj)
 
             if static_attrs is not None:
-                writeStatic(obj, static_attrs, class_ref)
-
-            if dynamic_attrs is not None:
+                writeStatic(obj_attrs, static_attrs, class_ref)
+
+            if class_def.encoding == ObjectEncoding.DYNAMIC and dynamic_attrs is not None:
                 for attr in dynamic_attrs:
                     self._writeString(attr)
-                    self.writeElement(util.get_attr(obj, attr))
+                    self.writeElement(obj_attrs[attr])
 
                 self._writeString("")
-        elif class_def.encoding == ObjectEncoding.STATIC:
-            static_attrs, dynamic_attrs = class_def.getAttrs(obj)
-
-            if static_attrs is not None:
-                writeStatic(obj, static_attrs, class_ref)
-        else:
-            raise pyamf.EncodeError, "Unknown object encoding"
 
     def writeByteArray(self, n, use_references=True):

pyamf/branches/logging-173/pyamf/remoting/__init__.py

@@ -18 +18 @@
 
 @see: U{Remoting Envelope on OSFlash (external)
-<http://osflash.org/documentation/amf/envelopes/remoting>}
+    <http://osflash.org/documentation/amf/envelopes/remoting>}
 @see: U{Remoting Headers on OSFlash (external)
-<http://osflash.org/amf/envelopes/remoting/headers>}
+    <http://osflash.org/amf/envelopes/remoting/headers>}
 @see: U{Remoting Debug Headers on OSFlash (external)
-<http://osflash.org/documentation/amf/envelopes/remoting/debuginfo>}
-
+    <http://osflash.org/documentation/amf/envelopes/remoting/debuginfo>}
 @author: U{Nick Joyce<mailto:nick@boxdesign.co.uk>}
-
 @since: 0.1.0
 """
 
+import logging
+
 import pyamf
 from pyamf import util
 
 __all__ = ['Envelope', 'Request', 'Response', 'decode', 'encode']
+
+logger = logging.getLogger(__name__)
 
 #: Succesful call.
@@ -492 +494 @@
     @param  stream: AMF data.
     @type   context: L{amf0.Context<pyamf.amf0.Context>} or
-    L{amf3.Context<pyamf.amf3.Context>}
+        L{amf3.Context<pyamf.amf3.Context>}
     @param  context: Context.
     @type strict: C{bool}
     @param strict: Enforce strict encoding.
 
-    @raise DecodeError: Malformed stream.
-    @raise RuntimeError: Decoder is unable to fully consume the
-    stream buffer.
-
     @return: Message envelope.
     @rtype: L{Envelope}
     """
+    logger.debug("decode - begin (stream=%r, context=%r, strict=%r)" % (
+        stream, context, strict))
+
     if not isinstance(stream, util.BufferedByteStream):
         stream = util.BufferedByteStream(stream)
@@ -525 +526 @@
     header_count = stream.read_ushort()
 
+    logger.debug("header count=%d" % header_count)
     for i in xrange(header_count):
         name, required, data = _read_header(stream, decoder, strict)
@@ -533 +535 @@
 
     body_count = stream.read_short()
+    logger.debug("body count=%d" % body_count)
     context.clear()
 
@@ -540 +543 @@
 
     if strict and stream.remaining() > 0:
-        raise RuntimeError, "Unable to fully consume the buffer"
+        raise RuntimeError, "Unable to fully consume the buffer (remaining:%d)" % stream.remaining()
+
+    logger.debug("decode - end (msg=%r)" % msg)
 
     return msg
@@ -560 +565 @@
     @return: File object.
     """
+    logger.debug("encode - begin (msg=%r, old_context=%r, strict=%r)" % (
+        msg, old_context, strict))
+
     def getNewContext():
         if old_context:
@@ -587 +595 @@
         encoder.context = getNewContext()
         _write_body(name, message, stream, encoder, strict)
+
+    logger.debug("encode - end (stream=%r)" % stream)
 
     return stream
@@ -595 +605 @@
         return pyamf.ERROR_CLASS_MAP[fault.code]
     except KeyError:
-        # default to RemotingError
         return RemotingError

pyamf/branches/logging-173/pyamf/tests/gateway/test_twisted.py

@@ -350 +350 @@
         self.assertTrue(isinstance(response.body, remoting.ErrorFault))
         self.assertEquals(response.body.code, 'IndexError')
-        
+
     def test_auth_fail(self):
         def auth(u, p):
@@ -611 +611 @@
             d2 = defer.Deferred()
             reactor.callLater(0, lambda: d2.callback(None))
-            
+
             return d2
 
@@ -658 +658 @@
                 self.assertTrue(result)
             except:
-                d.errback()                
+                d.errback()
             else:
                 d.callback(None)

pyamf/branches/logging-173/pyamf/tests/test_amf0.py

@@ -163 +163 @@
         self._run(data)
 
+    def test_bytestring(self):
+        class UnicodeObject:
+            def __unicode__(self):
+                return u'Mötley CrÃŒe'
+
+        class StrObject:
+            def __str__(self):
+                return u'Mötley CrÃŒe'
+
+        class ReprObject:
+            def __repr__(self):
+                return u'Mötley CrÃŒe'
+
+        self.encoder.writeString(UnicodeObject())
+        self.assertEquals(self.buf.getvalue(), '\x02\x00\x15M\xc3\x83\xc3\x82'
+            '\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+
+        self.encoder.writeString(StrObject())
+        self.assertEquals(self.buf.getvalue(), '\x02\x00\x15M\xc3\x83\xc3\x82'
+            '\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+
+        self.encoder.writeString(ReprObject())
+        self.assertEquals(self.buf.getvalue(), '\x02\x00\x15M\xc3\x83\xc3\x82'
+            '\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+
+        self.encoder.writeString('M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.assertEquals(self.buf.getvalue(), '\x02\x00\x15M\xc3\x83\xc3\x82'
+            '\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+
     def test_null(self):
         self._run([(None, '\x05')])
@@ -380 +412 @@
 
         pyamf.unregister_class(Person)
+
+    def test_getstate(self):
+        tc = self
+        tc.executed = False
+
+        class Foo(object):
+            def __getstate__(self):
+                tc.executed = True
+                return {'spam': 'hello', 'eggs': True}
+
+        pyamf.register_class(Foo, 'foo')
+
+        foo = Foo()
+        self.encoder.writeElement(foo)
+
+        self.assertEquals(self.buf.getvalue(), '\x10\x00\x03\x66\x6f\x6f\x00'
+            '\x04\x65\x67\x67\x73\x01\x01\x00\x04\x73\x70\x61\x6d\x02\x00\x05'
+            '\x68\x65\x6c\x6c\x6f\x00\x00\x09')
+        self.assertTrue(self.executed)
+
+        pyamf.unregister_class(Foo)
 
 class DecoderTestCase(unittest.TestCase):
@@ -612 +665 @@
         pyamf.unregister_class(Foo)
 
+    def test_setstate_newstyle(self):
+        self.executed = False
+
+        class Foo(object):
+            tc = self
+
+            def __init__(self, *args, **kwargs):
+                self.tc.fail("__init__ called")
+
+            def __setstate__(self, state):
+                self.tc.executed = True
+                self.__dict__.update(state)
+
+        pyamf.register_class(Foo, 'foo')
+
+        self.buf.write('\x10\x00\x03\x66\x6f\x6f\x00\x04\x65\x67\x67\x73\x01\x01\x00\x04')
+        self.buf.write('\x73\x70\x61\x6d\x02\x00\x05\x68\x65\x6c\x6c\x6f\x00\x00\x09')
+        self.buf.seek(0)
+
+        foo = self.decoder.readElement()
+
+        self.assertEquals(foo.spam, 'hello')
+        self.assertEquals(foo.eggs, True)
+        self.assertTrue(self.executed)
+
+        pyamf.unregister_class(Foo)
+
+    def test_setstate_classic(self):
+        self.executed = False
+
+        class Foo:
+            tc = self
+
+            def __init__(self, *args, **kwargs):
+                self.tc.fail("__init__ called")
+
+            def __setstate__(self, state):
+                self.tc.executed = True
+                self.__dict__.update(state)
+
+        pyamf.register_class(Foo, 'foo')
+
+        self.buf.write('\x10\x00\x03\x66\x6f\x6f\x00\x04\x65\x67\x67\x73\x01\x01\x00\x04')
+        self.buf.write('\x73\x70\x61\x6d\x02\x00\x05\x68\x65\x6c\x6c\x6f\x00\x00\x09')
+        self.buf.seek(0)
+
+        foo = self.decoder.readElement()
+
+        self.assertTrue(self.executed)
+        self.assertTrue(isinstance(foo, Foo))
+        self.assertEquals(foo.spam, 'hello')
+        self.assertEquals(foo.eggs, True)
+
+        pyamf.unregister_class(Foo)
+
 class HelperTestCase(unittest.TestCase):
     def test_encode(self):

pyamf/branches/logging-173/pyamf/tests/test_amf3.py

@@ -317 +317 @@
             (u'ᚠᛇᚻ', '\x06\x13\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')])
 
+    def test_bytestring(self):
+        class UnicodeObject:
+            def __unicode__(self):
+                return u'Mötley CrÃŒe'
+
+        class StrObject:
+            def __str__(self):
+                return u'Mötley CrÃŒe'
+
+        class ReprObject:
+            def __repr__(self):
+                return u'Mötley CrÃŒe'
+
+        self.encoder.writeString(UnicodeObject())
+        self.assertEquals(self.buf.getvalue(), '\x06+M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+        self.context.clear()
+
+        self.encoder.writeString(StrObject())
+        self.assertEquals(self.buf.getvalue(), '\x06+M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+        self.context.clear()
+
+        self.encoder.writeString(ReprObject())
+        self.assertEquals(self.buf.getvalue(), '\x06+M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.buf.truncate()
+        self.context.clear()
+
+        self.encoder.writeString('M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+        self.assertEquals(self.buf.getvalue(), '\x06+M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce')
+
+
     def test_string_references(self):
         self._run([
@@ -524 +556 @@
 
         pyamf.unregister_class(Person)
+
+    def test_getstate(self):
+        self.executed = False
+
+        class Foo(object):
+            tc = self
+
+            def __getstate__(self):
+                self.tc.executed = True
+                return {'spam': 'hello', 'eggs': True}
+
+        pyamf.register_class(Foo, 'foo')
+
+        foo = Foo()
+        self.encoder.writeElement(foo)
+
+        self.assertEquals(self.buf.getvalue(), '\x0a\x0b\x07\x66\x6f\x6f\x09'
+            '\x65\x67\x67\x73\x03\x09\x73\x70\x61\x6d\x06\x0b\x68\x65\x6c\x6c'
+            '\x6f\x01')
+        self.assertTrue(self.executed)
+
+        pyamf.unregister_class(Foo)
 
 class DecoderTestCase(unittest.TestCase):
@@ -768 +822 @@
         pyamf.unregister_class(Spam)
 
+    def test_setstate_newstyle(self):
+        self.executed = False
+
+        class Foo(object):
+            tc = self
+
+            def __init__(self, *args, **kwargs):
+                self.tc.fail("__init__ called")
+
+            def __setstate__(self, state):
+                self.tc.executed = True
+                self.__dict__.update(state)
+
+        pyamf.register_class(Foo, 'foo')
+
+        self.buf.write('\x0a\x0b\x07\x66\x6f\x6f\x09\x65\x67\x67\x73' + \
+            '\x03\x09\x73\x70\x61\x6d\x06\x0b\x68\x65\x6c\x6c\x6f\x01')
+        self.buf.seek(0)
+
+        foo = self.decoder.readElement()
+
+        self.assertEquals(foo.spam, 'hello')
+        self.assertEquals(foo.eggs, True)
+        self.assertTrue(self.executed)
+
+        pyamf.unregister_class(Foo)
+
+    def test_setstate_classic(self):
+        self.executed = False