Fixed error handling and added parameter type in every function

Author: sujata-m

src/python_ms_core/__init__.py

@@ -11,8 +11,6 @@
 load_dotenv()
 
 
-# FIXME: ADD parameter type should be present in each and every function
-# FIXME: ADD return type should be present in each and every function
 class Core:
 
     # FIXME: Fix the configuration
@@ -27,15 +25,13 @@ def __init__(self, config=None):
         if self.config.provider == 'Local':
             logging.error(f'Unimplemented initialization for core {self.config.provider}')
 
-    # FIXME: Change the function logic to take the configuration not from .env file if provided
     @staticmethod
     def initialize():
         return Core().__check_health()
 
     @staticmethod
     def get_logger(provider=None):
-        # TODO: Get logger fix local provider
-        if provider:
+        if provider and provider.lower() == 'local':
             return LocalLogger(provider_config=provider)
         else:
             return Logger()
@@ -48,13 +44,11 @@ def get_topic(topic_name: str):
         if topic_name is not None:
             return Topic(config=CoreConfig.default(), topic_name=topic_name)
         else:
-            # FIXME: Fix the error message
-            logging.error(f'Unimplemented initialization for core, Topic name required!')
+            logging.error(f'Error: Topic name is required as function parameter')
             return
 
     @staticmethod
     def get_storage_client():
-        # FIXME: Check the azure connection first before call the method
         return azure_storage_client.AzureStorageClient(AzureStorageConfig())
 
     def __check_health(self):

src/python_ms_core/core/logger/logger.py

@@ -12,7 +12,7 @@ def __init__(self):
         self.config = AzureServiceBusTopic()
         self.queue_client = Queue(self.config)
 
-    def add_request(self, request_data):
+    def add_request(self, request_data: dict):
         message = QueueMessage.data_from({
             'message': 'Add Request',
             'messageType': 'addRequest',

src/python_ms_core/core/queue/topic.py

@@ -24,6 +24,7 @@ def messages(self, provider, topic, subscription):
                     finally:
                         topic_receiver.complete_message(message)
 
+
 class Topic:
     def __init__(self, config=None, topic_name=None):
         self.topic = topic_name
@@ -40,6 +41,7 @@ def subscribe(self, subscription=None, callback=None):
         if subscription is not None:
             cb = Callback(callback)
             thread = threading.Thread(target=cb.messages, args=(self.provider,self.topic, subscription))
+            thread.daemon = True
             thread.start()
             time.sleep(5)
         else:
@@ -53,4 +55,3 @@ def publish(self, data=None):
             sender = self.provider.client.get_topic_sender(topic_name=self.provider.topic)
             with sender:
                 sender.send_messages(self.provider.sender(json.dumps(message)))
-        print('Message Sent')

src/python_ms_core/core/resource_errors/__init__.py

@@ -1,8 +1,15 @@
-import azure
 import operator
 from functools import wraps
 from .errors import BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, \
-    UnProcessableError, TooManyRequestError, ServiceError, TimeOutError
+    UnProcessableError, TooManyRequestError, ServiceError, TimeOutError, InternalServerError
+from azure.servicebus.exceptions import AutoLockRenewFailed, AutoLockRenewTimeout, MessageAlreadySettled, \
+    MessageLockLostError, MessageNotFoundError, MessageSizeExceededError, MessagingEntityAlreadyExistsError, \
+    MessagingEntityDisabledError, MessagingEntityNotFoundError, OperationTimeoutError, ServiceBusAuthenticationError, \
+    ServiceBusAuthorizationError, ServiceBusCommunicationError, ServiceBusConnectionError, ServiceBusError, \
+    ServiceBusQuotaExceededError, ServiceBusServerBusyError, SessionCannotBeLockedError, SessionLockLostError
+
+from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ServiceRequestError, \
+    ResourceNotFoundError, AzureError
 
 
 def parse_error(base_message, error):
@@ -11,21 +18,23 @@ def parse_error(base_message, error):
     description = ''
     if error.__class__ == TypeError:
         error = str(error)
+    try:
+        complete_message = error.split('\n') if operator.contains(str(error), '\n') else [error]
 
-    complete_message = error.split('\n') if operator.contains(str(error), '\n') else [error]
-
-    if complete_message and len(complete_message) > 0:
-        message = complete_message[0]
-    if complete_message and len(complete_message) > 1:
-        status_code_string = complete_message[1]
-        status_code_string = status_code_string.split('Status code: ')
-        if len(status_code_string) == 2:
-            status_code = int(status_code_string[1])
-    if complete_message and len(complete_message) > 2:
-        description_string = complete_message[2]
-        description_string = description_string.split('Description: ')
-        if len(description_string) == 2:
-            description = description_string[1]
+        if complete_message and len(complete_message) > 0:
+            message = complete_message[0]
+        if complete_message and len(complete_message) > 1:
+            status_code_string = complete_message[1]
+            status_code_string = status_code_string.split('Status code: ')
+            if len(status_code_string) == 2:
+                status_code = int(status_code_string[1])
+        if complete_message and len(complete_message) > 2:
+            description_string = complete_message[2]
+            description_string = description_string.split('Description: ')
+            if len(description_string) == 2:
+                description = description_string[1]
+    except Exception as e:
+        pass
 
     return {
         'message': f'{base_message}: {message}',
@@ -41,49 +50,59 @@ def decorated(fn):
         def wrapper(*args, **kwargs):
             try:
                 return fn(*args, **kwargs)
-            except azure.servicebus.exceptions.AutoLockRenewFailed as ex:
+            except AutoLockRenewFailed as ex:
                 raise BadRequestError(parse_error('AutoLock Renew Failed Error', ex.message))
-            except azure.servicebus.exceptions.AutoLockRenewTimeout as ex:
+            except AutoLockRenewTimeout as ex:
                 raise TimeOutError(parse_error('AutoLock Renew Timeout Error', ex.message))
-            except azure.servicebus.exceptions.MessageAlreadySettled as ex:
+            except MessageAlreadySettled as ex:
                 raise BadRequestError(parse_error('Message Already Settled Error', ex.message))
-            except azure.servicebus.exceptions.MessageLockLostError as ex:
+            except MessageLockLostError as ex:
                 raise BadRequestError(parse_error('Message Lock Lost Error', ex.message))
-            except azure.servicebus.exceptions.MessageNotFoundError as ex:
+            except MessageNotFoundError as ex:
                 raise NotFoundError(parse_error('Message Not Found Error', ex.message))
-            except azure.servicebus.exceptions.MessageSizeExceededError as ex:
+            except MessageSizeExceededError as ex:
                 raise BadRequestError(parse_error('Message Size Exceeded Error', ex.message))
-            except azure.servicebus.exceptions.MessagingEntityAlreadyExistsError as ex:
+            except MessagingEntityAlreadyExistsError as ex:
                 raise ConflictError(parse_error('Message Entity Already Exists Error', ex.message))
-            except azure.servicebus.exceptions.MessagingEntityDisabledError as ex:
+            except MessagingEntityDisabledError as ex:
                 raise UnProcessableError(parse_error('Message Entity Disabled Error', ex.message))
-            except azure.servicebus.exceptions.MessagingEntityNotFoundError as ex:
+            except MessagingEntityNotFoundError as ex:
                 raise NotFoundError(parse_error('Message Entity Not Found Error', ex.message))
-            except azure.servicebus.exceptions.OperationTimeoutError as ex:
+            except OperationTimeoutError as ex:
                 raise TimeOutError(parse_error('Operation Timeout Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusAuthenticationError as ex:
+            except ServiceBusAuthenticationError as ex:
                 raise NotFoundError(parse_error('Unable to Authenticate Service Bus Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusAuthorizationError as ex:
+            except ServiceBusAuthorizationError as ex:
                 raise ForbiddenError(parse_error('Unable to Authorization Service Bus Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusCommunicationError as ex:
+            except ServiceBusCommunicationError as ex:
                 raise UnProcessableError(parse_error('Service Bus Communication Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusConnectionError as ex:
+            except ServiceBusConnectionError as ex:
                 raise ForbiddenError(parse_error('Service Bus Connection Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusError as ex:
-                raise ForbiddenError(parse_error('Service Bus Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusQuotaExceededError as ex:
+            except ServiceBusQuotaExceededError as ex:
                 raise UnProcessableError(parse_error('Service Bus Quota Exceeded Error', ex.message))
-            except azure.servicebus.exceptions.ServiceBusServerBusyError as ex:
+            except ServiceBusServerBusyError as ex:
                 raise UnProcessableError(parse_error('Service Bus Server Busy Error', ex.message))
-            except azure.servicebus.exceptions.SessionCannotBeLockedError as ex:
+            except SessionCannotBeLockedError as ex:
                 raise UnProcessableError(parse_error('Session Cannot Be Locked Error', ex.message))
-            except azure.servicebus.exceptions.SessionLockLostError as ex:
+            except SessionLockLostError as ex:
                 raise UnProcessableError(parse_error('Session Lock Lost Error', ex.message))
+            except ServiceBusError as ex:
+                raise ForbiddenError(parse_error('Service Bus Error', ex.message))
+            except ClientAuthenticationError as ex:
+                raise UnauthorizedError(parse_error('Client Authentication Error', ex.message))
+            except ResourceNotFoundError as ex:
+                raise NotFoundError(parse_error('Resource Not Found Error', ex.message))
+            except HttpResponseError as ex:
+                raise UnProcessableError(parse_error('Http Response Error', ex.message))
+            except ServiceRequestError as ex:
+                raise UnProcessableError(parse_error('Service Request Error', ex.message))
+            except AzureError as ex:
+                raise NotFoundError(parse_error('Azure Error', ex.message))
             except ValueError as ex:
                 raise UnProcessableError(parse_error('UnProcessable Error', ex))
             except TypeError as ex:
                 raise ServiceError(parse_error('Service Error', ex))
             except Exception as ex:
-                raise ServiceError(parse_error('Exception', ex))
+                raise InternalServerError(parse_error('Exception', ex))
 
         return wrapper

src/python_ms_core/core/resource_errors/errors.py

@@ -45,3 +45,5 @@ class TooManyRequestError(ServiceError):
     status = 429
 
 
+class InternalServerError(ServiceError):
+    status = 500

src/python_ms_core/core/storage/providers/azure/azure_file_entity.py

@@ -1,5 +1,6 @@
 from azure.storage.blob import BlobClient
 from ...abstract import file_entity
+from ....resource_errors import ExceptionHandler
 
 
 class AzureFileEntity(file_entity.FileEntity):
@@ -10,15 +11,19 @@ def __init__(self, name, blob_client):
         self.blob_client = blob_client
         self._get_remote_url = None
 
+    @ExceptionHandler.decorated
     def get_stream(self):
         return self.blob_client.download_blob().readall()
 
+    @ExceptionHandler.decorated
     def get_body_text(self):
         return self.blob_client.download_blob().content_as_text()
 
+    @ExceptionHandler.decorated
     def upload(self, upload_stream):
         upload_file = self.blob_client.upload_blob(self.file_path, upload_stream)
         self._get_remote_url = upload_file.url
 
+    @ExceptionHandler.decorated
     def get_remote_url(self):
         return self._get_remote_url

src/python_ms_core/core/storage/providers/azure/azure_storage_client.py

@@ -1,34 +1,36 @@
 import logging
 import urllib.parse
 from azure.storage.blob import BlobServiceClient
-from ...abstract import storage_client
 from . import azure_storage_config, azure_file_entity, azure_storage_container
+from ...abstract import storage_client
+from ....resource_errors import ExceptionHandler
 
 
 class AzureStorageClient(storage_client.StorageClient):
     _blob_service_client: BlobServiceClient
 
     def __init__(self, config: azure_storage_config.AzureStorageConfig):
         super().__init__()
+        self.config = config
         self._blob_service_client = BlobServiceClient.from_connection_string(config.connection_string)
 
-    # TODO: Added exception handler here
-    # TODO: Like @ExceptionHandler.decorated
-    def get_container(self, container_name=None):
-        if container_name is not None:
+    @ExceptionHandler.decorated
+    def get_container(self, container_name: str):
+        if container_name:
             client_container = self._blob_service_client.get_container_client(container_name)
             return azure_storage_container.AzureStorageContainer(container_name, client_container)
         else:
             logging.error(f'Unimplemented initialization for core {self.config.provider}, Container name is required!')
             return
 
-    def get_file(self, container_name, file_name):
+    @ExceptionHandler.decorated
+    def get_file(self, container_name: str, file_name: str):
         client_container = self._blob_service_client.get_container_client(container_name)
         blob_client = client_container.get_blob_client(file_name)
-        properties = blob_client.get_blob_properties()
-        return azure_file_entity.AzureFileEntity(file_name, properties.blob_type, blob_client)
+        return azure_file_entity.AzureFileEntity(file_name, blob_client)
 
-    def get_file_from_url(self, container_name, full_url):
+    @ExceptionHandler.decorated
+    def get_file_from_url(self, container_name: str, full_url: str):
         path = '/'.join(urllib.parse.unquote(full_url).split('/')[4:])
         file = azure_file_entity.AzureFileEntity
         client_container = self._blob_service_client.get_container_client(container_name)

src/python_ms_core/core/storage/providers/azure/azure_storage_container.py

@@ -1,15 +1,17 @@
 from azure.storage.blob import ContainerClient
 from ...abstract import storage_container
 from ...providers.azure import azure_file_entity
+from ....resource_errors import ExceptionHandler
 
 
 class AzureStorageContainer(storage_container.StorageContainer):
     container_client = ContainerClient
 
-    def __init__(self, name, container_client: ContainerClient):
+    def __init__(self, name: str, container_client: ContainerClient):
         super().__init__(name)
         self.container_client = container_client
 
+    @ExceptionHandler.decorated
     def list_files(self):
         blob_iterator = self.container_client.list_blobs()
         files_list = [azure_file_entity.AzureFileEntity]
@@ -18,5 +20,6 @@ def list_files(self):
             files_list.append(azure_file_entity.AzureFileEntity(single_item.name, blob_client=blob_client))
         return files_list
 
-    def create_file(self, name):
+    @ExceptionHandler.decorated
+    def create_file(self, name: str):
         return azure_file_entity.AzureFileEntity(name, self.container_client)