Move error handling to api calls

- allows interpretation of diffferent evelink codes

celerytask/tasks.py

@@ -31,6 +31,7 @@ from eveonline.models import EveAllianceInfo
 from authentication.managers import AuthServicesInfoManager
 from services.models import DiscordAuthToken
 
+import evelink
 import time
 import logging
 
@@ -460,63 +461,30 @@ def refresh_api(api_key_pair):
         state = determine_membership_by_user(user)
         if state == "BLUE":
             if settings.BLUE_API_ACCOUNT:
-                type = EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key)
+                if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
-                if type == None:
-                    api_key_pair.error_count += 1
-                    api_key_pair.save()
-                    logger.info("API key %s incurred an error checking if type account. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
-                    still_valid = None
-                elif type == False:
                     logger.info("Determined api key %s for blue user %s is no longer type account as requred." % (api_key_pair.api_id, user))
                     still_valid = False
                     notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger")
-                full = EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key)
+                if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
-                if full == None:
-                    api_key_pair.error_count += 1
-                    api_key_pair.save()
-                    logger.info("API key %s incurred an error checking if meets mask requirements. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
-                    still_valid = None
-                elif full == False:
                     logger.info("Determined api key %s for blue user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
                     still_valid = False
                     notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger")
         elif state == "MEMBER":
             if settings.MEMBER_API_ACCOUNT:
-                type = EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key)
+                if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
-                if type == None:
-                    api_key_pair.error_count += 1
-                    api_key_pair.save()
-                    logger.info("API key %s incurred an error checking if type account. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
-                    still_valid = None
-                elif type == False:
                     logger.info("Determined api key %s for user %s is no longer type account as required." % (api_key_pair.api_id, user))
                     still_valid = False
                     notify(user, "API Failed Validation", message="Your API key ID %s is not account-wide as required." % api_key_pair.api_id, level="danger")
-                full = EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key)
+                if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
-                if full == None:
-                    api_key_pair.error_count += 1
-                    api_key_pair.save()
-                    logger.info("API key %s incurred an error checking if meets mask requirements. Error count is now %s" % (api_key_pair.api_id, api_key_pair.error_count))
-                    still_valid = None
-                elif full == False:
                     logger.info("Determined api key %s for user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
                     still_valid = False
                     notify(user, "API Failed Validation", message="Your API key ID %s does not meet access mask requirements." % api_key_pair.api_id, level="danger")
-        if still_valid == None:
+        if not still_valid:
-               if api_key_pair.error_count >= 3:
-                   logger.info("API key %s has incurred 3 or more errors. Assuming invalid." % api_key_pair.api_id)
-                   still_valid = False
-                   notify(user, "API Failed Validation", message="Your API key ID %s has accumulated too many errors during refresh and is assumed to be invalid." % api_key_pair.api_id, level="danger")
-        if still_valid == False:
            logger.debug("API key %s has failed validation; it and its characters will be deleted." % api_key_pair.api_id)
            EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
            EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
            notify(user, "API Key Deleted", message="Your API key ID %s has failed validation. It and its associated characters have been deleted." % api_key_pair.api_id, level="danger")
-        elif still_valid == True:
+        else:
-               if api_key_pair.error_count != 0:
-                   logger.info("Clearing error count for api %s as it passed validation" % api_key_pair.api_id)
-                   api_key_pair.error_count = 0
-                   api_key_pair.save()
            logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id)
            # Update characters
            characters = EveApiManager.get_characters_from_api(api_key_pair.api_id, api_key_pair.api_key)
@@ -551,7 +519,19 @@ def run_api_refresh():
                 authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user)
                 logger.debug("User %s has api keys. Proceeding to refresh." % user)
                 for api_key_pair in api_key_pairs:
+                    try:
                         refresh_api(api_key_pair)
+                    except evelink.api.APIError as e:
+                        if int(e.code) >= 500:
+                            logger.error("EVE API servers encountered an error. Aborting API updates")
+                            return
+                        elif int(e.code) == 221:
+                            logger.warn("API server hiccup while updating %s" % api_key_pair)
+                        else:
+                            logger.debug("API key %s failed update with error code %s" % (api_key_pair.api_id, e.code))
+                            EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
+                            EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
+                            notify(user, "API Key Deleted", message="Your API key ID %s failed validation with code %s. It and its associated characters have been deleted." % (api_key_pair.api_id, e.code), level="danger")
                 # Check our main character
                 if EveCharacter.objects.filter(character_id=authserviceinfo.main_char_id).exists() is False:
                     logger.info("User %s main character id %s missing model. Clearning main character." % (user, authserviceinfo.main_char_id))
@@ -625,7 +605,7 @@ def run_corp_update():
         logger.warn("Aborted updating corp and alliance models: API server unreachable")
         return
     standing_level = 'alliance'
-
+    try:
         # get corp info for owning corp if required
         ownercorpinfo = {}
         if settings.IS_CORP:
@@ -800,3 +780,5 @@ def run_corp_update():
                         corp.delete()
                 else:
                     logger.debug("Corp %s is owning corp" % corp)
+    except evelink.api.APIError as e:
+        logger.error("Model update failed with error code %s" % e.code)

eveonline/forms.py

@@ -4,6 +4,7 @@ from django.conf import settings
 from services.managers.eve_api_manager import EveApiManager
 from eveonline.managers import EveManager
 from eveonline.models import EveCharacter
+import evelink
 
 from celerytask.tasks import determine_membership_by_character
 
@@ -28,6 +29,7 @@ class UpdateKeyForm(forms.Form):
         super(UpdateKeyForm, self).clean()
 
         if 'api_id' in self.cleaned_data and 'api_key' in self.cleaned_data:
+            try:
                 if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']):
                     logger.debug("UpdateKeyForm failed cleaning as API id %s already exists." % self.cleaned_data['api_id'])
                     raise forms.ValidationError(u'API key already exist')
@@ -52,3 +54,9 @@ class UpdateKeyForm(forms.Form):
                     if EveApiManager.validate_blue_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False:
                         raise forms.ValidationError(u'API must meet blue requirements')
                 return self.cleaned_data
+            except evelink.api.APIError as e:
+                logger.debug("Got error code %s while validating API %s" % (e.code, self.cleaned_data['api_id']))
+                if int(e.code) in [221, 222]:
+                    raise forms.ValidationError("API key failed validation")
+                else:
+                    raise forms.ValidationError("Failed to reach API servers")

services/managers/eve_api_manager.py

@@ -16,14 +16,10 @@ class EveApiManager():
     def get_characters_from_api(api_id, api_key):
         chars = []
         logger.debug("Getting characters from api id %s" % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         # Should get characters
         account = evelink.account.Account(api=api)
         chars = account.characters()
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-
         logger.debug("Retrieved characters %s from api id %s" % (chars, api_id))
         return chars
 
@@ -31,15 +27,11 @@ class EveApiManager():
     def get_corporation_ticker_from_id(corp_id):
         logger.debug("Getting ticker for corp id %s" % corp_id)
         ticker = ""
-        try:
         api = evelink.api.API()
         corp = evelink.corp.Corp(api)
         response = corp.corporation_sheet(corp_id)
         logger.debug("Retrieved corp sheet for id %s: %s" % (corp_id, response))
         ticker = response[0]['ticker']
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-
         logger.debug("Determined corp id %s ticker: %s" % (corp_id, ticker))
         return ticker
 
@@ -47,13 +39,10 @@ class EveApiManager():
     def get_alliance_information(alliance_id):
         results = {}
         logger.debug("Getting info for alliance with id %s" % alliance_id)
-        try:
         api = evelink.api.API()
         eve = evelink.eve.EVE(api=api)
         alliance = eve.alliances()
         results = alliance[0][int(alliance_id)]
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
         logger.debug("Got alliance info %s" % results)
         return results
 
@@ -61,88 +50,57 @@ class EveApiManager():
     def get_corporation_information(corp_id):
         logger.debug("Getting info for corp with id %s" % corp_id)
         results = {}
-        try:
         api = evelink.api.API()
         corp = evelink.corp.Corp(api=api)
         corpinfo = corp.corporation_sheet(corp_id=int(corp_id))
         results = corpinfo[0]
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
         logger.debug("Got corp info %s" % results)
         return results
 
     @staticmethod
     def check_api_is_type_account(api_id, api_key):
         logger.debug("Checking if api id %s is account." % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         account = evelink.account.Account(api=api)
         info = account.key_info()
         logger.debug("API id %s is type %s" % (api_id, info[0]['type']))
         return info[0]['type'] == "account"
 
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-            return None
-
-
     @staticmethod
     def check_api_is_full(api_id, api_key):
         logger.debug("Checking if api id %s meets member requirements." % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         account = evelink.account.Account(api=api)
         info = account.key_info()
         logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.MEMBER_API_MASK))
         return info[0]['access_mask'] & int(settings.MEMBER_API_MASK) == int(settings.MEMBER_API_MASK)
 
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-            return None
-
     @staticmethod
     def check_blue_api_is_full(api_id, api_key):
         logger.debug("Checking if api id %s meets blue requirements." % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         account = evelink.account.Account(api=api)
         info = account.key_info()
         logger.debug("API has mask %s, required is %s" % (info[0]['access_mask'], settings.BLUE_API_MASK))
         return info[0]['access_mask'] & int(settings.BLUE_API_MASK) == int(settings.BLUE_API_MASK)
  
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-            return None
-
-
     @staticmethod
     def get_api_info(api_id, api_key):
         logger.debug("Getting api info for key id %s" % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         account = evelink.account.Account(api=api)
         info = account.key_info()
         logger.debug("Got info for api id %s: %s" % (api_id, info))
         return info
 
-        except evelink.api.APIError as error:
-            logger.exception("Unhandled APIError occured.")
-            return None
-
     @staticmethod
     def api_key_is_valid(api_id, api_key):
         logger.debug("Checking if api id %s is valid." % api_id)
-        try:
         api = evelink.api.API(api_key=(api_id, api_key))
         account = evelink.account.Account(api=api)
         info = account.key_info()
         logger.info("Verified api id %s is still valid." % api_id)
         return True
-        except evelink.api.APIError as error:
-            logger.exception("APIError occured while validating api id %s" % api_id)
-
-        logger.info("API id %s is invalid." % api_id)
-        return False
 
     @staticmethod
     def check_if_api_server_online():
@@ -170,6 +128,9 @@ class EveApiManager():
             logger.debug("Confirmed id %s is a corp." % corp_id)
             return True
         except evelink.api.APIError as error:
+            if int(error.code) == '523':
+                logger.debug("Confirmed id %s is not a corp" % corp_id)
+                return False
             logger.debug("APIError occured while checking if id %s is corp. Possibly not corp?" % corp_id)
 
         logger.debug("Unable to verify id %s is corp." % corp_id)
@@ -178,7 +139,6 @@ class EveApiManager():
     @staticmethod
     def get_corp_standings():
         if settings.CORP_API_ID and settings.CORP_API_VCODE:
-            try:
             logger.debug("Getting corp standings with api id %s" % settings.CORP_API_ID)
             api = evelink.api.API(api_key=(settings.CORP_API_ID, settings.CORP_API_VCODE))
             corp = evelink.corp.Corp(api=api)
@@ -186,8 +146,6 @@ class EveApiManager():
             results = corpinfo.result
             logger.debug("Got corp standings from settings: %s" % results)
             return results
-            except evelink.api.APIError as error:
-                logger.exception("Unhandled APIError occured.", exc_info=True)
         else:
             logger.error("No corp API key supplied in settings. Unable to get standings.")
         return {}