Improved handling exceptions.

Author: Thomas

netbox/connection.py

@@ -1,6 +1,6 @@
 import requests
-import socket
 from netbox import exceptions
+import json
 
 
 class NetboxConnection(object):
@@ -29,14 +29,14 @@ def __init__(self, ssl_verify=False, use_ssl=True, host=None, auth_token=None, a
             self.session.headers.update({'Content-Type': 'application/json'})
 
         if auth and auth_token:
-            raise ValueError('Only one authentication method is possible. Please use auth or auth_token')
+            raise exceptions.AuthException('Only one authentication method is possible. Please use auth or auth_token')
 
         if extra_headers:
             self.session.headers.update(extra_headers)
 
     def __request(self, method, params=None, key=None, body=None, url=None):
 
-        if method is not 'GET':
+        if method != 'GET':
             if not self.auth_token:
                 raise exceptions.AuthException('Authentication credentials were not provided')
 
@@ -54,25 +54,25 @@ def __request(self, method, params=None, key=None, body=None, url=None):
 
         try:
             response = self.session.send(prepared_request)
-        except socket.gaierror:
-            err_msg = 'Unable to find address: {}'.format(self.host)
-            raise socket.gaierror(err_msg)
         except requests.exceptions.ConnectionError:
             err_msg = 'Unable to connect to Netbox host: {}'.format(self.host)
-            raise ConnectionError(err_msg)
+            raise ConnectionError(err_msg) from None
         except requests.exceptions.Timeout:
-            raise TimeoutError('Connection to Netbox host timed out')
+            raise TimeoutError('Connection to Netbox host timed out') from None
         except Exception as e:
             raise Exception(e)
         finally:
             self.close()
 
+        if not 200 <= response.status_code < 300:
+            self.__raise_error(response.status_code, response.content)
+
         try:
             response_data = response.json()
-        except:
-            response_data = response.content
+        except json.JSONDecodeError:
+            raise exceptions.ServerException(response.content) from None
 
-        return response.ok, response.status_code, response_data
+        return response_data
 
     def get(self, param, key=None, limit=0, **kwargs):
 
@@ -87,15 +87,9 @@ def get(self, param, key=None, limit=0, **kwargs):
         else:
             url = '{}{}?limit={}'.format(self.base_url, param, limit)
 
-        resp_ok, resp_status, resp_data = self.__request('GET', params=param, key=key, url=url)
+        resp_data = self.__request('GET', params=param, key=key, url=url)
 
-        if resp_ok and resp_status == 200:
-            if 'results' in resp_data:
-                return resp_data['results']
-            else:
-                return resp_data
-        else:
-            return []
+        return resp_data['results']
 
     def put(self, params):
 
@@ -104,15 +98,9 @@ def put(self, params):
     def patch(self, params, key, **kwargs):
 
         body_data = {key: value for (key, value) in kwargs.items()}
-        resp_ok, resp_status, resp_data = self.__request('PATCH', params=params, key=key, body=body_data)
-
-        if resp_ok and resp_status == 200:
-            return resp_data
-
-        if resp_status == 404:
-            raise exceptions.NotFoundException("object not found with id {}".format(key), from_con=True)
+        resp_data = self.__request('PATCH', params=params, key=key, body=body_data)
 
-        raise exceptions.UpdateException(resp_data)
+        return resp_data
 
     def post(self, params, required_fields, **kwargs):
 
@@ -121,24 +109,33 @@ def post(self, params, required_fields, **kwargs):
         if kwargs:
             body_data.update({key: value for (key, value) in kwargs.items()})
 
-        resp_ok, resp_status, resp_data = self.__request('POST', params=params, body=body_data)
-        if resp_ok and resp_status == 201:
-            return resp_data
-        else:
-            raise exceptions.CreateException(resp_data)
+        resp_data = self.__request('POST', params=params, body=body_data)
+
+        return resp_data
 
     def delete(self, params, del_id):
 
         del_str = '{}{}'.format(params, del_id)
-        resp_ok, resp_status, resp_data = self.__request('DELETE', del_str)
-        if resp_ok and resp_status == 204:
-            return True
-
-        if resp_status == 404:
-            raise exceptions.NotFoundException("Unable to found object with id {}".format(del_id), from_con=True)
+        self.__request('DELETE', del_str)
 
-        raise exceptions.DeleteException(resp_data)
+        return True
 
     def close(self):
 
         self.session.close()
+
+    def __raise_error(self, http_status_code, http_response):
+        """Raise error with detailed information from http request."""
+        try:
+            error_msg = json.loads(http_response)
+        except json.JSONDecodeError:
+            error_msg = http_response
+
+        if http_status_code == 404:
+            raise exceptions.NotFoundException(error_msg)
+        elif http_status_code == 403:
+            raise exceptions.AuthorizationException(error_msg)
+        elif http_status_code == 400:
+            raise exceptions.ClientException(error_msg)
+        elif http_status_code == 503:
+            raise exceptions.ServerException(error_msg)

netbox/exceptions.py

@@ -1,58 +1,62 @@
-class BaseExceptions(Exception):
-    pass
-
-
-class DeleteException(BaseException):
-    """Raised when delete failed"""
+class GeneralException(BaseException):
     def __init__(self, resp_data):
-
         if isinstance(resp_data, dict):
-            self.err = ''.join('Failed with reason {}'.format(val) for key, val in resp_data.items())
+            if 'detail' in resp_data:
+                self.err = resp_data['detail']
+            else:
+                self.err = ''.join('{} '.format(val[0]) for key, val in resp_data.items())
         else:
-            self.err = 'Delete failed with an unknown reason'
+            self.err = 'Unknown Error, please check the Netbox logs'
 
     def __str__(self):
         return '{}'.format(self.err)
 
 
-class NotFoundException(BaseException):
+class DeleteException(GeneralException):
+    """Raised when delete failed"""
+    def __init__(self, resp_data):
+        super().__init__(resp_data)
+
+
+class NotFoundException(GeneralException):
     """Raised when item is not found"""
-    def __init__(self, msg, from_con=False):
-        self.msg = msg
-        self.from_con = from_con
+    pass
 
-    def __str__(self):
-        if self.from_con:
-            return self.msg
 
-        return 'Unable to found {}'.format(self.msg)
+class GetException(GeneralException):
+    pass
 
 
-class CreateException(BaseException):
+class CreateException(GeneralException):
     """Raised when creation failed"""
     def __init__(self, resp_data):
-
-        if isinstance(resp_data, dict):
-            self.err = ''.join('{} '.format(val[0]) for key, val in resp_data.items())
-        else:
-            self.err = 'Creation failed with unknown reason'
-
-    def __str__(self):
-        return '{}'.format(self.err)
+        super().__init__(resp_data)
 
 
 class UpdateException(BaseException):
     """Raised when an object update fails"""
     def __init__(self, resp_data):
-        if isinstance(resp_data, dict):
-            self.err = ''.join('{} '.format(val[0]) for key, val in resp_data.items())
-        else:
-            self.err = 'Update failed with unknown reason'
-
-    def __str__(self):
-        return '{}'.format(self.err)
+        super().__init__(resp_data)
 
 
 class AuthException(BaseException):
     """Raised when an API call method is not allowed"""
     pass
+
+
+class AuthorizationException(GeneralException):
+    """HTTP 403 status code"""
+    def __init__(self, resp_data):
+        super().__init__(resp_data)
+
+
+class ClientException(GeneralException):
+    """HTTP 400 status code"""
+    def __init__(self, resp_data):
+        super().__init__(resp_data)
+
+
+class ServerException(GeneralException):
+    """HTTP 5xx status code"""
+    def __init__(self, resp_data):
+        super().__init__(resp_data)