Refactor HTTP-related exceptions

* Refactor helper function that builds the map of http status codes
  to local http exceptions - now we don't have to explicitly list
  every single exception name
* Add several exceptions to represent http status codes that were not
  previously represented
* Improve consistency of exceptions naming by prepending 'HTTP' to
  necessary exception names
* Use HTTPException instead of ClientException
* Deprecate old http exceptions (those that aren't prefixed with HTTP)
* Deprecate ClientException
* Deprecate unused NoTokenLookupException and EndpointNotFound
* Add test module to spot-check the from_response helper

Change-Id: Ibc7fef9e2a5b24bd001d183d377901f302d650a9

glanceclient/exc.py

@@ -13,130 +13,133 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Exception definitions.
-"""
+import sys
 
 
 class CommandError(Exception):
+    """Invalid usage of CLI"""
     pass
 
 
-class NoTokenLookupException(Exception):
-    """This form of authentication does not support looking up
-       endpoints from an existing token."""
+class InvalidEndpoint(ValueError):
+    """The provided endpoint could not be used"""
     pass
 
 
-class EndpointNotFound(Exception):
-    """Could not find Service or Region in Service Catalog."""
+class ClientException(Exception):
+    """DEPRECATED"""
+
+
+class HTTPException(ClientException):
+    """Base exception for all HTTP-derived exceptions"""
+    code = 'N/A'
+
+    def __init__(self, details=None):
+        self.details = details
+
+    def __str__(self):
+        return "%s (HTTP %s)" % (self.__class__.__name__, self.code)
+
+
+class BadRequest(HTTPException):
+    """DEPRECATED"""
+    code = 400
+
+
+class HTTPBadRequest(BadRequest):
     pass
 
 
-class InvalidEndpoint(ValueError):
-    """The provided endpoint could not be used"""
+class Unauthorized(HTTPException):
+    """DEPRECATED"""
+    code = 401
+
+
+class HTTPUnauthorized(Unauthorized):
     pass
 
 
-class ClientException(Exception):
-    """
-    The base exception class for all exceptions this library raises.
-    """
-    def __init__(self, code, message=None, details=None):
-        self.code = code
-        self.message = message or self.__class__.message
-        self.details = details
+class Forbidden(HTTPException):
+    """DEPRECATED"""
+    code = 403
 
-    def __str__(self):
-        return "%s (HTTP %s)" % (self.message, self.code)
+
+class HTTPForbidden(Forbidden):
+    pass
 
 
-class BadRequest(ClientException):
-    """
-    HTTP 400 - Bad request: you sent some malformed data.
-    """
-    http_status = 400
-    message = "Bad request"
+class NotFound(HTTPException):
+    """DEPRECATED"""
+    code = 404
 
 
-class Unauthorized(ClientException):
-    """
-    HTTP 401 - Unauthorized: bad credentials.
-    """
-    http_status = 401
-    message = "Unauthorized"
+class HTTPNotFound(NotFound):
+    pass
 
 
-class Forbidden(ClientException):
-    """
-    HTTP 403 - Forbidden: your credentials don't give you access to this
-    resource.
-    """
-    http_status = 403
-    message = "Forbidden"
+class HTTPMethodNotAllowed(HTTPException):
+    code = 405
 
 
-class NotFound(ClientException):
-    """
-    HTTP 404 - Not found
-    """
-    http_status = 404
-    message = "Not found"
+class Conflict(HTTPException):
+    """DEPRECATED"""
+    code = 409
 
 
-class Conflict(ClientException):
-    """
-    HTTP 409 - Conflict
-    """
-    http_status = 409
-    message = "Conflict"
+class HTTPConflict(Conflict):
+    pass
 
 
-class OverLimit(ClientException):
-    """
-    HTTP 413 - Over limit: you're over the API limits for this time period.
-    """
-    http_status = 413
-    message = "Over limit"
+class OverLimit(HTTPException):
+    """DEPRECATED"""
+    code = 413
 
 
-class InternalServerError(ClientException):
-    """
-    HTTP 500 - Internal Server Error
-    """
-    http_status = 500
-    message = "Internal Server Error"
+class HTTPOverLimit(OverLimit):
+    pass
 
 
-# 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"
+class HTTPInternalServerError(HTTPException):
+    code = 500
 
 
-class ServiceUnavailable(ClientException):
-    """
-    HTTP 503 - Service Unavailable
-    """
-    http_status = 503
-    message = "Service Unavailable"
+class HTTPNotImplemented(HTTPException):
+    code = 501
 
 
-# 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:
-_exc_list = [BadRequest, Unauthorized, Forbidden, NotFound, OverLimit,
-             InternalServerError, HTTPNotImplemented, ServiceUnavailable]
-_code_map = dict((c.http_status, c) for c in _exc_list)
+class HTTPBadGateway(HTTPException):
+    code = 502
+
+
+class ServiceUnavailable(HTTPException):
+    """DEPRECATED"""
+    code = 503
+
+
+class HTTPServiceUnavailable(ServiceUnavailable):
+    pass
+
+
+#NOTE(bcwaldon): Build a mapping of HTTP codes to corresponding exception
+# classes
+_code_map = {}
+for obj_name in dir(sys.modules[__name__]):
+    if obj_name.startswith('HTTP'):
+        obj = getattr(sys.modules[__name__], obj_name)
+        _code_map[obj.code] = obj
 
 
 def from_response(response):
-    """Return an instance of an ClientException based on httplib response."""
-    cls = _code_map.get(response.status, ClientException)
-    return cls(code=response.status)
+    """Return an instance of an HTTPException based on httplib response."""
+    cls = _code_map.get(response.status, HTTPException)
+    return cls()
+
+
+class NoTokenLookupException(Exception):
+    """DEPRECATED"""
+    pass
+
+
+class EndpointNotFound(Exception):
+    """DEPRECATED"""
+    pass

tests/test_exc.py

@@ -0,0 +1,29 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import collections
+import unittest
+
+from glanceclient import exc
+
+
+FakeResponse = collections.namedtuple('HTTPResponse', ['status'])
+
+
+class TestHTTPExceptions(unittest.TestCase):
+    def test_from_response(self):
+        """exc.from_response should return instance of an HTTP exception"""
+        out = exc.from_response(FakeResponse(400))
+        self.assertTrue(isinstance(out, exc.HTTPBadRequest))