[#400] more advanced iRODSException representation

The most notable change here is that we now include the OS/Errno information
in the __repr__ result for any exception class based on iRODSException.

Author: d-w-moore

irods/exception.py

@@ -3,8 +3,12 @@
 
 
 from __future__ import absolute_import
-import six
+from __future__ import print_function
+import errno
 import numbers
+import os
+import six
+import sys
 
 
 class PycommandsException(Exception):
@@ -61,14 +65,72 @@ class MultipleResultsFound(QueryException):
 
 class iRODSExceptionMeta(type):
     codes = {}
-
+    positive_code_error_message = "For {name}, a positive code of {attrs[code]} was declared."
     def __init__(self, name, bases, attrs):
         if 'code' in attrs:
+            if attrs['code'] > 0:
+                print(self.positive_code_error_message.format(**locals()), file = sys.stderr)
+                exit(1)
             iRODSExceptionMeta.codes[attrs['code']] = self
 
 
+class Errno:
+    """Encapsulates an integer error code from the operating system
+       and provides a text representation.
+    """
+    def __init__(self,arg0,*_):
+        """Initializes an object with an integer error code arg0.
+           Further arguments are optional and ignored.
+        """
+        self.int_code = arg0
+
+    def __repr__(self):
+        e = self.int_code
+        try:
+            return self.__class__.__name__ + repr(tuple([e, errno.errorcode[e], os.strerror(e)]))
+        except:
+            # The errno code is unrecognized, so fall through to default representation.
+            pass
+        return self.__class__.__name__ + repr(tuple([e,]))
+
+    def __int__(self):
+        return self.int_code
+
+
 class iRODSException(six.with_metaclass(iRODSExceptionMeta, Exception)):
-    pass
+    """An exception that originates from a server error.
+       Exception classes that are derived from this base and represent a concrete error, should
+       store a unique error code (X*1000) in their 'code' attribute, where X < 0.
+    """
+
+    def __init__(self,*arg):
+        explicit_errno = None
+        argl = list(arg)
+
+        # For consistency with the text representation, allow initialization with an Errno object
+        # at the end of the argument list.
+        # Example: err = UNIX_FILE_OPEN_ERR('message', Errno(13))
+        #          err_copy = eval(repr(err))
+        if hasattr(self.__class__,'code'):
+            if argl and isinstance (argl[-1],Errno):
+                explicit_errno = argl.pop()
+
+        super(iRODSException,self).__init__(*argl)
+
+        # To properly represent the Errno instance, the "code" attribute should be (-errno) plus the thousands
+        # attribute stored in the class's code attribute.  Because Python honors the instance "code" attribute
+        # over the class "code" attribute, the following does _not_ modify the class:
+        if explicit_errno:
+            self.code -= int(explicit_errno)
+
+    def __repr__(self):
+        args = tuple(self.args)
+        code = getattr(self,'code',None)
+        if code is not None:
+            os_err = abs(code) % 1000
+            if os_err: args += (Errno(os_err),)
+        return self.__class__.__name__ + repr(args)
+
 
 
 def nominal_code( the_code, THRESHOLD = 1000 ):

irods/test/exception_test.py

@@ -0,0 +1,50 @@
+#! /usr/bin/env python
+from __future__ import print_function
+from __future__ import absolute_import
+from datetime import datetime
+import errno
+import os
+import sys
+import unittest
+import irods.test.helpers as helpers
+import irods.exception
+
+
+class TestException(unittest.TestCase):
+
+    def setUp(self):
+        # open the session (per-test)
+        self.sess = helpers.make_session()
+
+    def tearDown(self):
+        # close the session (per-test)
+        self.sess.cleanup()
+
+    def test_400(self):
+        ses = self.sess
+        data = ''
+        try:
+            seed = helpers.my_function_name() + ":" + str(datetime.now())
+            data = helpers.home_collection(ses) + "/" + helpers.unique_name(seed,'data')
+            exc = None
+            with helpers.create_simple_resc(self,vault_path = '/home') as resc_name:
+                try:
+                    # iRODS will attempt to make a data object where it doesn't have permission
+                    ses.data_objects.create(data,resource = resc_name)
+                except Exception as e:
+                    exc = e
+            self.assertIsNotNone(exc, 'Creating data object in unwriteable vault did not raise an error as it should.')
+            excep_repr = repr(exc)
+            errno_object = irods.exception.Errno(errno.EACCES)
+            errno_repr = repr(errno_object)
+            self.assertRegexpMatches(errno_repr,r'\bErrno\b')
+            self.assertRegexpMatches(errno_repr,'''['"]{msg}['"]'''.format(msg = os.strerror(errno.EACCES)))
+            self.assertIn( errno_repr, excep_repr)
+        finally:
+            if ses.data_objects.exists(data):
+                ses.data_objects.unlink(data,force = True)
+
+if __name__ == '__main__':
+    # let the tests find the parent irods lib
+    sys.path.insert(0, os.path.abspath('../..'))
+    unittest.main()

irods/test/helpers.py

@@ -193,15 +193,15 @@ def make_flat_test_dir(dir_path, file_count=10, file_size=1024):
             f.write(os.urandom(file_size))
 
 @contextlib.contextmanager
-def create_simple_resc (self, rescName = None):
+def create_simple_resc (self, rescName = None, vault_path = ''):
     if not rescName: 
         rescName =  'simple_resc_' + unique_name (my_function_name() + '_simple_resc', datetime.datetime.now())
     created = False
     try:
         self.sess.resources.create(rescName,
                                    'unixfilesystem',
                                    host = self.sess.host,
-                                   path = '/tmp/' + rescName)
+                                   path = vault_path or '/tmp/' + rescName)
         created = True
         yield rescName
     finally: