Refactor error code into exceptions

This makes the exceptions more self describing and simplifies httpapi and sockapi.
An important step to improve asynchttp conveyance of error data that would normally
be an http error in synchronous operation.

confluent_server/confluent/exceptions.py

@@ -24,53 +24,61 @@ class ConfluentException(Exception):
     apierrorstr = 'Unexpected Error'
 
     def get_error_body(self):
-        return self.apierrorstr
+        errstr = ' - '.join((self.apierrorstr, str(self)))
+        return json.dumps({'error': errstr })
 
 
 class NotFoundException(ConfluentException):
     # Something that could be construed as a name was not found
     # basically, picture an http error code 404
-    pass
+    apierrorcode = 404
+    apierrorstr = 'Request path not recognized'
 
 
 class InvalidArgumentException(ConfluentException):
     # Something from the remote client wasn't correct
     # like http code 400
-    pass
+    apierrorcode = 400
+    apierrorstr = 'Bad Request'
 
 
 class TargetEndpointUnreachable(ConfluentException):
     # A target system was unavailable.  For example, a BMC
     # was unreachable.  http code 504
-    pass
+    apierrorcode = 504
+    apierrorstr = 'Unreachable Target'
 
 
 class TargetEndpointBadCredentials(ConfluentException):
     # target was reachable, but authentication/authorization
     # failed
-    pass
+    apierrorcode = 502
+    apierrorstr = 'Bad Credentials'
 
 
 class LockedCredentials(ConfluentException):
     # A request was performed that required a credential, but the credential
     # store is locked
-    pass
+    apierrorstr = 'Credential store locked'
 
 
 class ForbiddenRequest(ConfluentException):
     # The client request is not allowed by authorization engine
-    pass
+    apierrorcode = 403
+    apierrorstr = 'Forbidden'
 
 
 class NotImplementedException(ConfluentException):
     # The current configuration/plugin is unable to perform
     # the requested task. http code 501
-    pass
+    apierrorcode = 501
+    apierrorstr = '501 - Not Implemented'
+
 
 
 class GlobalConfigError(ConfluentException):
     # The configuration in the global config file is not right
-    pass
+    apierrorstr = 'Global configuration contains an error'
 
 
 class PubkeyInvalid(ConfluentException):

confluent_server/confluent/httpapi.py

@@ -588,26 +588,9 @@ def resourcehandler_backend(env, start_response):
                     pagecontent += datum
             start_response('200 OK', headers)
             yield pagecontent
-        except exc.NotFoundException as ne:
-            start_response('404 Not found', headers)
-            yield "404 - Request path not recognized - " + str(ne)
-        except exc.InvalidArgumentException as e:
-            start_response('400 Bad Request - ' + str(e), headers)
-            yield '400 - Bad Request - ' + str(e)
-        except exc.TargetEndpointUnreachable as tu:
-            start_response('504 Unreachable Target', headers)
-            yield '504 - Unreachable Target - ' + str(tu)
-        except exc.TargetEndpointBadCredentials:
-            start_response('502 Bad Credentials', headers)
-            yield '502 - Bad Credentials'
-        except exc.LockedCredentials:
-            start_response('500 Locked credential store', headers)
-            yield '500 - Credential store locked'
-        except exc.NotImplementedException:
-            start_response('501 Not Implemented', headers)
-            yield '501 Not Implemented'
         except exc.ConfluentException as e:
-            if e.apierrorcode == 500:
+            if ((not isinstance(e, exc.LockedCredentials)) and
+                    e.apierrorcode == 500):
                 # raise generics to trigger the tracelog
                 raise
             start_response('{0} {1}'.format(e.apierrorcode, e.apierrorstr),

confluent_server/confluent/sockapi.py

@@ -118,37 +118,9 @@ def sessionhdl(connection, authname, skipauth=False):
         try:
             process_request(
                 connection, request, cfm, authdata, authname, skipauth)
-        except exc.ForbiddenRequest:
-            send_data(connection, {'errorcode': 403,
-                                      'error': 'Forbidden'})
-            send_data(connection, {'_requestdone': 1})
-        except exc.TargetEndpointBadCredentials:
-            send_data(connection, {'errorcode': 502,
-                                      'error': 'Bad Credentials'})
-            send_data(connection, {'_requestdone': 1})
-        except exc.TargetEndpointUnreachable as tu:
-            send_data(connection, {'errorcode': 504,
-                                      'error': 'Unreachable Target - ' + str(
-                                          tu)})
-            send_data(connection, {'_requestdone': 1})
-        except exc.NotImplementedException:
-            send_data(connection, {'errorcode': 501,
-                                      'error': 'Not Implemented'})
-            send_data(connection, {'_requestdone': 1})
-        except exc.NotFoundException as nfe:
-            send_data(connection, {'errorcode': 404,
-                                      'error': str(nfe)})
-            send_data(connection, {'_requestdone': 1})
-        except exc.InvalidArgumentException as iae:
-            send_data(connection, {'errorcode': 400,
-                                      'error': 'Bad Request - ' + str(iae)})
-            send_data(connection, {'_requestdone': 1})
-        except exc.LockedCredentials as lockedcred:
-            send_data(connection, {'errorcode': 500,
-                                      'error': 'Locked Credential Store'})
-            send_data(connection, {'_requestdone': 1})
         except exc.ConfluentException as e:
-            if e.apierrorcode == 500:
+            if ((not isinstance(e, exc.LockedCredentials)) and
+                    e.apierrorcode == 500):
                 tracelog.log(traceback.format_exc(), ltype=log.DataTypes.event,
                          event=log.Events.stacktrace)
             send_data(connection, {'errorcode': e.apierrorcode,