Revert "Reuse exceptions from Oslo"

This reverts commit 3bde9c3f42.

This change is a part of a series that is not backwards compatible.
It broke applications using the client library.

Change-Id: Id01a0a0feb601539d3855f445ebaf6a3cc000610
Partial-Bug: #1340596

novaclient/exceptions.py

@@ -16,31 +16,161 @@
 Exception definitions.
 """
 
-import inspect
-import sys
 
-import six
-
-from novaclient.openstack.common.apiclient.exceptions import *  # noqa
-
-# NOTE(akurilin): Since v.2.17.0 this alias should be left here to support
-# backwards compatibility.
-OverLimit = RequestEntityTooLarge
+class UnsupportedVersion(Exception):
+    """Indicates that the user is trying to use an unsupported
+    version of the API.
+    """
+    pass
 
 
-class NoTokenLookupException(ClientException):
+class CommandError(Exception):
+    pass
+
+
+class AuthorizationFailure(Exception):
+    pass
+
+
+class NoUniqueMatch(Exception):
+    pass
+
+
+class AuthSystemNotFound(Exception):
+    """When the user specify a AuthSystem but not installed."""
+    def __init__(self, auth_system):
+        self.auth_system = auth_system
+
+    def __str__(self):
+        return "AuthSystemNotFound: %s" % repr(self.auth_system)
+
+
+class NoTokenLookupException(Exception):
     """This form of authentication does not support looking up
        endpoints from an existing token.
     """
     pass
 
 
+class EndpointNotFound(Exception):
+    """Could not find Service or Region in Service Catalog."""
+    pass
+
+
+class AmbiguousEndpoints(Exception):
+    """Found more than one matching endpoint in Service Catalog."""
+    def __init__(self, endpoints=None):
+        self.endpoints = endpoints
+
+    def __str__(self):
+        return "AmbiguousEndpoints: %s" % repr(self.endpoints)
+
+
+class ConnectionRefused(Exception):
+    """
+    Connection refused: the server refused the connection.
+    """
+    def __init__(self, response=None):
+        self.response = response
+
+    def __str__(self):
+        return "ConnectionRefused: %s" % repr(self.response)
+
+
 class InstanceInErrorState(Exception):
     """Instance is in the error state."""
     pass
 
 
-class RateLimit(RequestEntityTooLarge):
+class ClientException(Exception):
+    """
+    The base exception class for all exceptions this library raises.
+    """
+    message = 'Unknown Error'
+
+    def __init__(self, code, message=None, details=None, request_id=None,
+                 url=None, method=None):
+        self.code = code
+        self.message = message or self.__class__.message
+        self.details = details
+        self.request_id = request_id
+        self.url = url
+        self.method = method
+
+    def __str__(self):
+        formatted_string = "%s (HTTP %s)" % (self.message, self.code)
+        if self.request_id:
+            formatted_string += " (Request-ID: %s)" % self.request_id
+
+        return formatted_string
+
+
+class BadRequest(ClientException):
+    """
+    HTTP 400 - Bad request: you sent some malformed data.
+    """
+    http_status = 400
+    message = "Bad request"
+
+
+class Unauthorized(ClientException):
+    """
+    HTTP 401 - Unauthorized: bad credentials.
+    """
+    http_status = 401
+    message = "Unauthorized"
+
+
+class Forbidden(ClientException):
+    """
+    HTTP 403 - Forbidden: your credentials don't give you access to this
+    resource.
+    """
+    http_status = 403
+    message = "Forbidden"
+
+
+class NotFound(ClientException):
+    """
+    HTTP 404 - Not found
+    """
+    http_status = 404
+    message = "Not found"
+
+
+class MethodNotAllowed(ClientException):
+    """
+    HTTP 405 - Method Not Allowed
+    """
+    http_status = 405
+    message = "Method Not Allowed"
+
+
+class Conflict(ClientException):
+    """
+    HTTP 409 - Conflict
+    """
+    http_status = 409
+    message = "Conflict"
+
+
+class OverLimit(ClientException):
+    """
+    HTTP 413 - Over limit: you're over the API limits for this time period.
+    """
+    http_status = 413
+    message = "Over limit"
+
+    def __init__(self, *args, **kwargs):
+        try:
+            self.retry_after = int(kwargs.pop('retry_after'))
+        except (KeyError, ValueError):
+            self.retry_after = 0
+
+        super(OverLimit, self).__init__(*args, **kwargs)
+
+
+class RateLimit(OverLimit):
     """
     HTTP 429 - Rate limit: you've sent too many requests for this time period.
     """
@@ -48,11 +178,25 @@ class RateLimit(RequestEntityTooLarge):
     message = "Rate limit"
 
 
-_code_map = dict(
-    (getattr(obj, 'http_status', None), obj)
-    for name, obj in six.iteritems(vars(sys.modules[__name__]))
-    if inspect.isclass(obj) and getattr(obj, 'http_status', False)
-)
+# NotImplemented is a python keyword.
+class HTTPNotImplemented(ClientException):
+    """
+    HTTP 501 - Not Implemented: the server does not support this operation.
+    """
+    http_status = 501
+    message = "Not Implemented"
+
+
+# In Python 2.4 Exception is old-style and thus doesn't have a __subclasses__()
+# so we can do this:
+#     _code_map = dict((c.http_status, c)
+#                      for c in ClientException.__subclasses__())
+#
+# Instead, we have to hardcode it:
+_error_classes = [BadRequest, Unauthorized, Forbidden, NotFound,
+                  MethodNotAllowed, Conflict, OverLimit, RateLimit,
+                  HTTPNotImplemented]
+_code_map = dict((c.http_status, c) for c in _error_classes)
 
 
 class InvalidUsage(RuntimeError):
@@ -77,7 +221,7 @@ def from_response(response, body, url, method=None):
             raise exception_from_response(resp, rest.text)
     """
     kwargs = {
-        'http_status': response.status_code,
+        'code': response.status_code,
         'method': method,
         'url': url,
         'request_id': None,

novaclient/tests/test_http.py

@@ -150,7 +150,7 @@ class ClientTest(utils.TestCase):
         # Python 2.7 and testtools doesn't match that implementation yet
         try:
             cl.get('/hi')
-        except exceptions.ServiceUnavailable as exc:
-            self.assertIn('Service Unavailable (HTTP 503)', six.text_type(exc))
+        except exceptions.ClientException as exc:
+            self.assertIn('Unknown Error', six.text_type(exc))
         else:
-            self.fail('Expected exceptions.ServiceUnavailable')
+            self.fail('Expected exceptions.ClientException')

novaclient/tests/test_utils.py

@@ -89,15 +89,15 @@ class FindResourceTestCase(test_utils.TestCase):
 
     def test_find_none(self):
         """Test a few non-valid inputs."""
-        self.assertRaises(exceptions.ResourceNotFound,
+        self.assertRaises(exceptions.CommandError,
                           utils.find_resource,
                           self.manager,
                           'asdf')
-        self.assertRaises(exceptions.ResourceNotFound,
+        self.assertRaises(exceptions.CommandError,
                           utils.find_resource,
                           self.manager,
                           None)
-        self.assertRaises(exceptions.ResourceNotFound,
+        self.assertRaises(exceptions.CommandError,
                           utils.find_resource,
                           self.manager,
                           {})

novaclient/tests/v1_1/test_shell.py

@@ -990,7 +990,7 @@ class ShellTest(utils.TestCase):
         self.assert_called('GET', '/flavors/1', pos=-1)
 
     def test_show_bad_id(self):
-        self.assertRaises(exceptions.ResourceNotFound,
+        self.assertRaises(exceptions.CommandError,
                           self.run_command, 'show xxx')
 
     @mock.patch('novaclient.v1_1.shell.utils.print_dict')

novaclient/utils.py

@@ -242,7 +242,7 @@ def find_resource(manager, name_or_id, **find_args):
             msg = _("No %(class)s with a name or ID of '%(name)s' exists.") % \
                   {'class': manager.resource_class.__name__.lower(),
                    'name': name_or_id}
-            raise exceptions.ResourceNotFound(msg)
+            raise exceptions.CommandError(msg)
     except exceptions.NoUniqueMatch:
         msg = (_("Multiple %(class)s matches found for '%(name)s', use an ID "
                  "to be more specific.") %