def setUp(self):
import pyamf
try:
pyamf.get_class_alias(status.Status)
except pyamf.UnknownClassAlias:
self._old_alias = None
else:
raise RuntimeError(
'Unexpected status.Status class registered in PyAMF')
self.alias = pyamf.register_class(status.Status)
def setUp(self):
import pyamf
try:
pyamf.get_class_alias(status.Status)
except pyamf.UnknownClassAlias:
self._old_alias = None
else:
raise RuntimeError(
'Unexpected status.Status class registered in PyAMF')
self.alias = pyamf.register_class(status.Status)
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=['foo'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), ['foo'])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['bar'])
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attrs=['foo', 'bar'], attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['foo', 'bar'])
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (None, None))
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=["foo"])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (["foo"], []))
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), (None, None))
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ["bar"]
pyamf.register_class(Spam, attr_func=af, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ([], ["bar"]))
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ["bar"]
pyamf.register_class(Spam, attrs=["foo", "bar"], attr_func=af, metadata=["dynamic"])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), (["foo", "bar"], []))
def test_get_attrs(self):
pyamf.register_class(Spam)
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, attrs=['foo'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), ['foo'])
pyamf.unregister_class(Spam)
pyamf.register_class(Spam, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
x = Spam()
self.assertEquals(alias.getAttrs(x), None)
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['bar'])
pyamf.unregister_class(Spam)
def af(x):
self.assertEquals(self._obj, x)
return ['bar']
pyamf.register_class(Spam, attrs=['foo', 'bar'], attr_func=af, metadata=['dynamic'])
alias = pyamf.get_class_alias(Spam)
self._obj = Spam()
self.assertEquals(alias.getAttrs(self._obj), ['foo', 'bar'])
def getClassAlias(self, klass):
"""
Gets a class alias based on the supplied C{klass}. If one is not found
in the global context, one is created locally.
If you supply a string alias and the class is not registered,
L{pyamf.UnknownClassAlias} will be raised.
@param klass: A class object or string alias.
@return: The L{pyamf.ClassAlias} instance that describes C{klass}
"""
try:
return self._class_aliases[klass]
except KeyError:
pass
try:
alias = self._class_aliases[klass] = pyamf.get_class_alias(klass)
except pyamf.UnknownClassAlias:
if isinstance(klass, python.str_types):
raise
# no alias has been found yet .. check subclasses
alias = util.get_class_alias(klass) or pyamf.ClassAlias
meta = util.get_class_meta(klass)
alias = alias(klass, defer=True, **meta)
self._class_aliases[klass] = alias
return alias
def getClassAlias(self, klass):
"""
Gets a class alias based on the supplied C{klass}. If one is not found
in the global context, one is created locally.
If you supply a string alias and the class is not registered,
L{pyamf.UnknownClassAlias} will be raised.
@param klass: A class object or string alias.
@return: The L{pyamf.ClassAlias} instance that describes C{klass}
"""
try:
return self._class_aliases[klass]
except KeyError:
pass
try:
alias = self._class_aliases[klass] = pyamf.get_class_alias(klass)
except pyamf.UnknownClassAlias:
if isinstance(klass, python.str_types):
raise
# no alias has been found yet .. check subclasses
alias = util.get_class_alias(klass) or pyamf.ClassAlias
meta = util.get_class_meta(klass)
alias = alias(klass, defer=True, **meta)
self._class_aliases[klass] = alias
return alias
def test_class_alias(self):
alias_klass = pyamf.get_class_alias(blobstore.BlobInfo)
self.assertIdentical(
alias_klass.__class__,
adapter.BlobInfoClassAlias
)
def test_get_class_alias(self):
self.assertTrue(Spam not in pyamf.CLASS_CACHE)
self.assertRaises(pyamf.UnknownClassAlias, pyamf.get_class_alias, "spam.eggs")
pyamf.register_class(Spam, "spam.eggs")
x = pyamf.get_class_alias("spam.eggs")
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, "spam.eggs")
x = pyamf.get_class_alias(Spam)
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, "spam.eggs")
def test_anonymous(self):
pyamf.register_class(Spam)
x = pyamf.get_class_alias(Spam)
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, '%s.%s' % (Spam.__module__, Spam.__name__,))
def test_user(self):
from django.contrib.auth import models
alias = pyamf.get_class_alias(models.User)
self.assertEqual(alias, 'django.contrib.auth.models.User')
self.assertEqual(alias.exclude_attrs, ('message_set', 'password'))
self.assertEqual(alias.readonly_attrs, ('username', ))
def test_user(self):
from django.contrib.auth import models
alias = pyamf.get_class_alias(models.User)
self.assertEqual(alias, 'django.contrib.auth.models.User')
self.assertEqual(alias.exclude_attrs, ('message_set', 'password'))
self.assertEqual(alias.readonly_attrs, ('username',))
def test_anonymous(self):
pyamf.register_class(Spam)
x = pyamf.get_class_alias(Spam)
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, '%s.%s' % (Spam.__module__, Spam.__name__,))
def test_get_class_alias(self):
self.assertTrue(Spam not in pyamf.CLASS_CACHE)
self.assertRaises(pyamf.UnknownClassAlias, pyamf.get_class_alias,
'spam.eggs')
pyamf.register_class(Spam, 'spam.eggs')
x = pyamf.get_class_alias('spam.eggs')
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, 'spam.eggs')
x = pyamf.get_class_alias(Spam)
self.assertTrue(isinstance(x, pyamf.ClassAlias))
self.assertEquals(x.klass, Spam)
self.assertEquals(x.alias, 'spam.eggs')
def test_alias(self):
alias = pyamf.get_class_alias(self.cls)
alias.compile()
self.assertTrue(alias.sealed)
self.assertFalse(alias.dynamic)
self.assertEquals(alias.alias, 'DSA')
self.assertTrue(alias.external)
def _compile_base_class(self, klass):
if klass is object:
return
try:
alias = pyamf.get_class_alias(klass)
except UnknownClassAlias:
alias = pyamf.register_class(klass)
alias.compile()
self.bases.append((klass, alias))
if alias.exclude_attrs:
self.exclude_attrs.update(alias.exclude_attrs)
if alias.readonly_attrs:
self.readonly_attrs.update(alias.readonly_attrs)
if alias.static_attrs:
self.static_attrs_set.update(alias.static_attrs)
for a in alias.static_attrs:
if a not in self.static_attrs:
self.static_attrs.insert(0, a)
if alias.proxy_attrs:
self.proxy_attrs.update(alias.proxy_attrs)
if alias.encodable_properties:
self.encodable_properties.update(alias.encodable_properties)
if alias.decodable_properties:
self.decodable_properties.update(alias.decodable_properties)
if self.amf3 is None and alias.amf3:
self.amf3 = alias.amf3
if self.dynamic is None and alias.dynamic is not None:
self.inherited_dynamic = alias.dynamic
if alias.sealed is not None:
self.inherited_sealed = alias.sealed
if alias.synonym_attrs:
# Note that self.synonym_attrs might be None, even if
# alias.synonym_attrs is defined
self.synonym_attrs, x = alias.synonym_attrs.copy(), self.synonym_attrs
self.synonym_attrs.update(x or {})
def _compile_base_class(self, klass):
if klass is object:
return
try:
alias = pyamf.get_class_alias(klass)
except UnknownClassAlias:
alias = pyamf.register_class(klass)
alias.compile()
self.bases.append((klass, alias))
if alias.exclude_attrs:
self.exclude_attrs.update(alias.exclude_attrs)
if alias.readonly_attrs:
self.readonly_attrs.update(alias.readonly_attrs)
if alias.static_attrs:
self.static_attrs_set.update(alias.static_attrs)
for a in alias.static_attrs:
if a not in self.static_attrs:
self.static_attrs.insert(0, a)
if alias.proxy_attrs:
self.proxy_attrs.update(alias.proxy_attrs)
if alias.encodable_properties:
self.encodable_properties.update(alias.encodable_properties)
if alias.decodable_properties:
self.decodable_properties.update(alias.decodable_properties)
if self.amf3 is None and alias.amf3:
self.amf3 = alias.amf3
if self.dynamic is None and alias.dynamic is not None:
self.inherited_dynamic = alias.dynamic
if alias.sealed is not None:
self.inherited_sealed = alias.sealed
if alias.synonym_attrs:
x = self.synonym_attrs
self.synonym_attrs = alias.synonym_attrs.copy()
self.synonym_attrs.update(x)
def _getClassDefinition(self, ref):
"""
Reads class definition from the stream.
"""
is_ref = ref & REFERENCE_BIT == 0
ref >>= 1
if is_ref:
class_def = self.context.getClassByReference(ref)
return class_def
name = self.readBytes()
alias = None
if name == '':
name = pyamf.ASObject
try:
alias = pyamf.get_class_alias(name)
except pyamf.UnknownClassAlias:
if self.strict:
raise
alias = pyamf.TypedObjectClassAlias(name)
class_def = ClassDefinition(alias)
class_def.encoding = ref & 0x03
class_def.attr_len = ref >> 2
class_def.static_properties = []
if class_def.attr_len > 0:
for i in range(class_def.attr_len):
key = self.readBytes()
class_def.static_properties.append(key)
self.context.addClass(class_def, alias.klass)
return class_def
def _getClassDefinition(self, ref):
"""
Reads class definition from the stream.
"""
is_ref = ref & REFERENCE_BIT == 0
ref >>= 1
if is_ref:
class_def = self.context.getClassByReference(ref)
return class_def
name = self.readBytes()
alias = None
if name == '':
name = pyamf.ASObject
try:
alias = pyamf.get_class_alias(name)
except pyamf.UnknownClassAlias:
if self.strict:
raise
alias = pyamf.TypedObjectClassAlias(name)
class_def = ClassDefinition(alias)
class_def.encoding = ref & 0x03
class_def.attr_len = ref >> 2
class_def.static_properties = []
if class_def.attr_len > 0:
for i in xrange(class_def.attr_len):
key = self.readBytes()
class_def.static_properties.append(key)
self.context.addClass(class_def, alias.klass)
return class_def
def test_create(self):
x = amf3.ClassDefinition('')
self.assertEquals(x.alias, None)
self.assertEquals(x.encoding, 2)
self.assertEquals(x.static_attrs, [])
self.assertEquals(len(x.static_attrs), 0)
x = amf3.ClassDefinition(None)
self.assertEquals(x.alias, None)
self.assertEquals(x.encoding, 2)
self.assertEquals(x.static_attrs, [])
self.assertEquals(len(x.static_attrs), 0)
pyamf.register_class(Spam, 'spam.eggs')
x = amf3.ClassDefinition('spam.eggs')
self.assertTrue(isinstance(x.alias, pyamf.ClassAlias))
self.assertEquals(x.alias, pyamf.get_class_alias('spam.eggs'))
self.assertEquals(x.encoding, 2)
self.assertEquals(x.static_attrs, [])
self.assertEquals(len(x.static_attrs), 0)
def readTypedObject(self):
"""
Reads an ActionScript object from the stream and attempts to
'cast' it.
@see: L{load_class<pyamf.load_class>}
"""
classname = self.readString()
alias = None
try:
alias = pyamf.get_class_alias(classname)
ret = alias.createInstance(codec=self)
except pyamf.UnknownClassAlias:
if self.strict:
raise
ret = pyamf.TypedObject(classname)
self.context.addObject(ret)
self._readObject(ret, alias)
return ret
def readTypedObject(self):
"""
Reads an ActionScript object from the stream and attempts to
'cast' it.
@see: L{load_class<pyamf.load_class>}
"""
classname = self.readString()
alias = None
try:
alias = pyamf.get_class_alias(classname)
ret = alias.createInstance(codec=self)
except pyamf.UnknownClassAlias:
if self.strict:
raise
ret = pyamf.TypedObject(classname)
self.context.addObject(ret)
self._readObject(ret, alias)
return ret
def test_aliased(self):
for x in ['DSC', 'DSK', 'DSC']:
alias = pyamf.get_class_alias(x)
self.assertTrue(alias.klass.__module__.startswith(plasma.__name__))
"""
Remoting server implementations.
@author: U{Thijs Triemstra<mailto:[email protected]>}
@author: U{Nick Joyce<mailto:[email protected]>}
@since: 0.1.0
"""
import types
import pyamf
from pyamf import remoting, logging, util
fault_alias = pyamf.get_class_alias(remoting.ErrorFault)
class BaseServiceError(pyamf.BaseError):
"""
Base service error.
"""
pyamf.register_class(BaseServiceError, attrs=fault_alias.attrs)
del fault_alias
class UnknownServiceError(BaseServiceError):
"""
Client made a request for an unknown service.
"""
_amf_code = 'Service.ResourceNotFound'
"""
Remoting server implementations.
@since: 0.1.0
"""
import sys, types
import pyamf
from pyamf import remoting, logging, util
SERVER_NAME = 'PyAMF/%s Python/%s' % ('.'.join(
map(lambda x: str(x), pyamf.__version__)), '.'.join(
map(lambda x: str(x), sys.version_info[0:3])))
fault_alias = pyamf.get_class_alias(remoting.ErrorFault)
class BaseServiceError(pyamf.BaseError):
"""
Base service error.
"""
pyamf.register_class(BaseServiceError, attrs=fault_alias.attrs)
del fault_alias
class UnknownServiceError(BaseServiceError):
"""
Client made a request for an unknown service.
def writeObject(self, obj, use_proxies=None):
"""
Writes an object to the stream.
@param obj: The object data to be encoded to the AMF3 data stream.
@type obj: object data
@raise EncodeError: Encoding an object in amf3 tagged as amf0 only.
"""
if use_proxies is None:
use_proxies = self.use_proxies
if use_proxies is True:
self.writeProxy(obj)
return
self.stream.write(TYPE_OBJECT)
ref = self.context.getObjectReference(obj)
if ref is not None:
self._writeInteger(ref << 1)
return
self.context.addObject(obj)
# object is not referenced, serialise it
kls = obj.__class__
definition = self.context.getClass(kls)
alias = None
class_ref = False # if the class definition is a reference
if definition:
class_ref = True
alias = definition.alias
if alias.anonymous and definition.reference is not None:
class_ref = True
else:
try:
alias = pyamf.get_class_alias(kls)
except pyamf.UnknownClassAlias:
alias_klass = util.get_class_alias(kls)
meta = util.get_class_meta(kls)
alias = alias_klass(kls, defer=True, **meta)
definition = ClassDefinition(alias)
self.context.addClass(definition, alias.klass)
if class_ref:
self.stream.write(definition.reference)
else:
ref = 0
if definition.encoding != ObjectEncoding.EXTERNAL:
ref += definition.attr_len << 4
final_reference = encode_int(ref | definition.encoding << 2 |
REFERENCE_BIT << 1 | REFERENCE_BIT)
self.stream.write(final_reference)
definition.reference = encode_int(
definition.reference << 2 | REFERENCE_BIT)
if alias.anonymous:
self.stream.write_uchar(0x01)
else:
self._writeString(alias.alias)
# work out what the final reference for the class will be.
# this is okay because the next time an object of the same
# class is encoded, class_ref will be True and never get here
# again.
if alias.external:
obj.__writeamf__(DataOutput(self))
return
attrs = alias.getEncodableAttributes(obj, codec=self)
if alias.static_attrs:
if not class_ref:
[self._writeString(attr) for attr in alias.static_attrs]
for attr in alias.static_attrs:
value = attrs.pop(attr)
self.writeElement(value)
if definition.encoding == ObjectEncoding.STATIC:
return
if definition.encoding == ObjectEncoding.DYNAMIC:
if attrs:
for attr, value in attrs.iteritems():
self._writeString(attr)
self.writeElement(value)
self.stream.write_uchar(0x01)
def test_class_alias(self):
alias_klass = pyamf.get_class_alias(blobstore.BlobInfo)
self.assertIdentical(alias_klass.__class__, adapter_blobstore.BlobInfoClassAlias)
"""
AMF3 RemoteObject support.
@see: U{RemoteObject on LiveDocs
<http://livedocs.adobe.com/flex/3/langref/mx/rpc/remoting/RemoteObject.html>}
@since: 0.1.0
"""
import calendar, time, uuid, sys
import pyamf
from pyamf import remoting
from pyamf.flex import messaging
error_alias = pyamf.get_class_alias(messaging.ErrorMessage)
class BaseServerError(pyamf.BaseError):
"""
Base server error.
"""
class ServerCallFailed(BaseServerError):
"""
A catchall error.
"""
_amf_code = 'Server.Call.Failed'
pyamf.register_class(ServerCallFailed, attrs=error_alias.attrs)
del error_alias
@see: U{RemoteObject on LiveDocs
<http://livedocs.adobe.com/flex/3/langref/mx/rpc/remoting/RemoteObject.html>}
@author: U{Nick Joyce<mailto:[email protected]>}
@since: 0.1.0
"""
import calendar, time, uuid, sys
import pyamf
from pyamf import remoting
from pyamf.flex.messaging import *
error_alias = pyamf.get_class_alias(ErrorMessage)
class BaseServerError(pyamf.BaseError):
"""
Base server errror
"""
class ServerCallFailed(BaseServerError):
"""
A catchall error.
"""
_amf_code = 'Server.Call.Failed'
pyamf.register_class(ServerCallFailed, attrs=error_alias.attrs)
def test_aliased(self):
alias = pyamf.get_class_alias('flex.messaging.messages.RemotingMessage')
self.assertTrue(alias.klass.__module__.startswith(plasma.__name__))
def test_alias(self):
alias = pyamf.get_class_alias(self.alias)
self.assertIdentical(alias.klass, graphics.ImageSnapshot)
