Changeset 1003

Timestamp:

02/11/08 21:42:26 (11 months ago)

Author:

nick

Message:

Merging source:pyamf/branches/error-api-185. Fixes #185 & #167

Location:

pyamf/trunk

Files:

• CHANGES.txt (modified) (1 diff)
• pyamf/__init__.py (modified) (3 diffs)
• pyamf/remoting/__init__.py (modified) (6 diffs)
• pyamf/remoting/client/__init__.py (modified) (1 diff)
• pyamf/tests/test_basic.py (modified) (2 diffs)
• pyamf/tests/test_remoting.py (modified) (2 diffs)
• pyamf/tests/test_sol.py (modified) (1 diff)

pyamf/trunk/CHANGES.txt

@@ -6 +6 @@
 of PyAMF.
 
-0.1rc1 (unreleased)
+0.1 (unreleased)
 -------------------
 
+ - a new error handling api useful for registering custom exception classes
+   (Ticket:185)
+ - when a client receives a remoting error, an exception is generated (Ticket:167)
  - expose_request per service control vastly improved (Ticket:169)
  - Authentication per service control vastly improved (Ticket:166)

pyamf/trunk/pyamf/__init__.py

@@ -44 +44 @@
 TYPE_MAP = {}
 
+#: Maps error classes to string codes
+ERROR_CLASS_MAP = {}
+
 #: Specifies that objects are serialized using AMF for ActionScript 1.0 and 2.0.
 AMF0 = 0
@@ -89 +92 @@
     """
 
-class EOStream(DecodeError):
+class EOStream(BaseError):
     """
     Raised if the data stream has come to a natural end.
@@ -992 +995 @@
     return declaration
 
+def add_error_class(klass, code):
+    """
+    Maps an exception class to a string code. Used to map remoting onStatus
+    objects to an exception class so that an exception can be built to
+    represent that error.
+
+    class AuthenticationError(Exception):
+        pass
+
+    An example: add_error_class(AuthenticationError, 'Auth.Failed')
+    """
+    if not isinstance(code, basestring):
+        code = str(code)
+
+    if not isinstance(klass, (type, types.ClassType)):
+        raise TypeError, "klass must be a class type"
+
+    mro = util.get_mro(klass)
+
+    if not Exception in util.get_mro(klass):
+        raise TypeError, 'error classes must subclass the __builtin__.Exception class'
+
+    if code in ERROR_CLASS_MAP.keys():
+        raise ValueError, 'Code %s is already registered' % code
+
+    ERROR_CLASS_MAP[code] = klass
+
+def remove_error_class(klass):
+    """
+    Removes a class from ERROR_CLASS_MAP
+    """
+    if isinstance(klass, basestring):
+        if not klass in ERROR_CLASS_MAP.keys():
+            raise ValueError, 'Code %s is not registered' % klass
+    elif isinstance(klass, (type, types.ClassType)):
+        classes = ERROR_CLASS_MAP.values()
+        if not klass in classes:
+            raise ValueError, 'Class %s is not registered' % klass
+
+        klass = ERROR_CLASS_MAP.keys()[classes.index(klass)]
+    else:
+        raise TypeError, "Invalid type, expected class or string"
+
+    del ERROR_CLASS_MAP[klass]
+
 register_adapters()

pyamf/trunk/pyamf/remoting/__init__.py

@@ -51 +51 @@
 CONTENT_TYPE = 'application/x-amf'
 
+ERROR_CALL_FAILED, = range(1)
+ERROR_CODES = {
+    ERROR_CALL_FAILED: 'Server.Call.Failed'
+}
+
 class RemotingError(pyamf.BaseError):
     """
     Generic remoting error class.
     """
+
+class RemotingCallFailed(RemotingError):
+    """
+    Raised if Server.Call.Failed received
+    """
+
+pyamf.add_error_class(RemotingCallFailed, ERROR_CODES[ERROR_CALL_FAILED])
 
 class HeaderCollection(dict):
@@ -233 +245 @@
         return x + '>'
 
+    def raiseException(self):
+        """
+        Raises an exception based on the fault object. There is no traceback
+        available.
+        """
+        raise get_exception_from_fault(self), self.description, None
+
 pyamf.register_class(BaseFault,
     attrs=['level', 'code', 'type', 'details', 'description'])
@@ -243 +262 @@
     level = 'error'
 
-pyamf.register_class(ErrorFault,
-    attrs=['level', 'code', 'type', 'details', 'description'])
+pyamf.register_class(ErrorFault)
 
 def _read_header(stream, decoder, strict=False):
@@ -443 +461 @@
     return STATUS_CODES[status]
 
-def get_fault_class(level):
+def get_fault_class(level, **kwargs):
+    code = kwargs.get('code', )
     if level == 'error':
         return ErrorFault
@@ -464 +483 @@
             e[x] = y
 
-    return get_fault_class(level)(**e)
+    return get_fault_class(level, **e)(**e)
 
 def decode(stream, context=None, strict=False):
@@ -569 +588 @@
 
     return stream
+
+def get_exception_from_fault(fault):
+    # XXX nick: threading problems here?
+    try:
+        return pyamf.ERROR_CLASS_MAP[fault.code]
+    except KeyError:
+        # default to RemotingError
+        return RemotingError

pyamf/trunk/pyamf/remoting/client/__init__.py

@@ -144 +144 @@
         self.response = response
         self.result = self.response.body
+
+        if isinstance(self.result, remoting.ErrorFault):
+            self.result.raiseException()
 
     def _get_result(self):

pyamf/trunk/pyamf/tests/test_basic.py

@@ -612 +612 @@
         self.assertEquals(td, td2)
 
+class ErrorClassMapTestCase(unittest.TestCase):
+    """
+    I test all functionality related to manipulating L{pyamf.ERROR_CLASS_MAP}
+    """
+
+    def setUp(self):
+        self.map_copy = pyamf.ERROR_CLASS_MAP.copy()
+
+    def tearDown(self):
+        pyamf.ERROR_CLASS_MAP = self.map_copy
+
+    def test_add(self):
+        class A:
+            pass
+
+        class B(Exception):
+            pass
+
+        self.assertRaises(TypeError, pyamf.add_error_class, None, 'a')
+
+        # class A does not sub-class Exception
+        self.assertRaises(TypeError, pyamf.add_error_class, A, 'a')
+
+        pyamf.add_error_class(B, 'b')
+        self.assertEquals(pyamf.ERROR_CLASS_MAP['b'], B)
+
+        pyamf.add_error_class(B, 'a')
+        self.assertEquals(pyamf.ERROR_CLASS_MAP['a'], B)
+
+        class C(Exception):
+            pass
+
+        self.assertRaises(ValueError, pyamf.add_error_class, C, 'b')
+
+    def test_remove(self):
+        class B(Exception):
+            pass
+
+        pyamf.ERROR_CLASS_MAP['abc'] = B
+
+        self.assertRaises(TypeError, pyamf.remove_error_class, None)
+
+        pyamf.remove_error_class('abc')
+        self.assertFalse('abc' in pyamf.ERROR_CLASS_MAP.keys())
+        self.assertRaises(KeyError, pyamf.ERROR_CLASS_MAP.__getitem__, 'abc')
+
+        pyamf.ERROR_CLASS_MAP['abc'] = B
+
+        pyamf.remove_error_class(B)
+
+        self.assertRaises(KeyError, pyamf.ERROR_CLASS_MAP.__getitem__, 'abc')
+        self.assertRaises(ValueError, pyamf.remove_error_class, B)
+        self.assertRaises(ValueError, pyamf.remove_error_class, 'abc')
+
 def suite():
     suite = unittest.TestSuite()
@@ -623 +677 @@
     suite.addTest(unittest.makeSuite(ClassLoaderTestCase))
     suite.addTest(unittest.makeSuite(TypeMapTestCase))
+    suite.addTest(unittest.makeSuite(ErrorClassMapTestCase))
 
     return suite

pyamf/trunk/pyamf/tests/test_remoting.py

@@ -270 +270 @@
             '\x00\x0c\n\x00\x00\x00\x01\x02\x00\x04spam')
 
+class FaultTestCase(unittest.TestCase):
+    def test_exception(self):
+        x = remoting.get_fault({'level': 'error', 'code': 'Server.Call.Failed'})
+
+        self.assertRaises(remoting.RemotingCallFailed, x.raiseException)
+
 def suite():
     """
@@ -279 +285 @@
     suite.addTest(unittest.makeSuite(EncoderTestCase))
     suite.addTest(unittest.makeSuite(StrictEncodingTestCase))
+    suite.addTest(unittest.makeSuite(FaultTestCase))
 
     from pyamf.tests.remoting import test_client, test_remoteobject

pyamf/trunk/pyamf/tests/test_sol.py

@@ -12 +12 @@
 """
 
-import unittest, os, os.path
+import unittest, os, os.path, warnings
 
 import pyamf
 from pyamf import amf0, util, sol
+
+warnings.simplefilter('ignore', RuntimeWarning)
 
 class DecoderTestCase(unittest.TestCase):