snapctl 0.32.0__py3-none-any.whl → 0.32.1__py3-none-any.whl

snapctl/commands/snapend.py

@@ -1,7 +1,6 @@
 """
   Snapend CLI commands
 """
-from sys import platform
 from typing import Union
 
 import os
@@ -10,12 +9,20 @@ import time
 import requests
 from requests.exceptions import RequestException
 
+import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from snapctl.config.constants import SERVER_CALL_TIMEOUT
+from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_SNAPEND_ENUMERATE_ERROR, SNAPCTL_SNAPEND_CLONE_SERVER_ERROR, \
+    SNAPCTL_SNAPEND_CLONE_TIMEOUT_ERROR, SNAPCTL_SUCCESS, SNAPCTL_SNAPEND_CLONE_ERROR, \
+    SNAPCTL_SNAPEND_APPLY_SERVER_ERROR, SNAPCTL_SNAPEND_APPLY_TIMEOUT_ERROR, \
+    SNAPCTL_SNAPEND_APPLY_ERROR, SNAPCTL_SNAPEND_PROMOTE_SERVER_ERROR, \
+    SNAPCTL_SNAPEND_PROMOTE_TIMEOUT_ERROR, SNAPCTL_SNAPEND_PROMOTE_ERROR, \
+    SNAPCTL_SNAPEND_DOWNLOAD_ERROR, SNAPCTL_SNAPEND_UPDATE_TIMEOUT_ERROR, \
+    SNAPCTL_SNAPEND_UPDATE_ERROR, SNAPCTL_SNAPEND_STATE_ERROR
 from snapctl.config.hashes import CLIENT_SDK_TYPES, SERVER_SDK_TYPES, PROTOS_TYPES, \
     SNAPEND_MANIFEST_TYPES
-from snapctl.types.definitions import ResponseType
 from snapctl.utils.echo import error, success, info
+from snapctl.utils.helper import snapctl_error, snapctl_success
 
 
 class Snapend:
@@ -77,6 +84,10 @@ class Snapend:
         self.byogs_list: str | None = Snapend._make_byogs_list(
             byogs) if byogs else None
         self.blocking: bool = blocking
+        # Validate input
+        self.validate_input()
+
+    # Helpers
 
     @staticmethod
     def _get_manifest_file_name(manifest_path: str) -> str | None:
@@ -137,7 +148,7 @@ class Snapend:
                     'state' in cluster_object['cluster']:
                 return cluster_object['cluster']['state']
         except RequestException as e:
-            error(f"Exception: Unable to get Snapend state {e}")
+            info(f"Exception: Unable to get Snapend state {e}")
         return 'INVALID'
 
     def _blocking_get_status(self) -> bool:
@@ -152,7 +163,7 @@ class Snapend:
                 if current_state == 'LIVE':
                     success('Updated your snapend. Your snapend is Live.')
                     return True
-                error(
+                info(
                     f"Update not completed successfully. Your Snapend status is {current_state}.")
                 return False
             info(f'Current snapend state is {current_state}')
@@ -215,13 +226,10 @@ class Snapend:
                     f"snapser-{self.snapend_id}-{self.category}"
                     f"-{self.platform_type}-{self.auth_type}.zip"
                 )
-            file_path_symbol = '/'
-            if platform == 'win32':
-                file_path_symbol = '\\'
             if self.out_path is not None:
-                file_save_path = f"{self.out_path}{file_path_symbol}{fn}"
+                file_save_path = os.path.join(self.out_path, fn)
             else:
-                file_save_path = f"{os.getcwd()}{file_path_symbol}{fn}"
+                file_save_path = os.path.join(os.getcwd(), fn)
             if res.ok:
                 content: bytes = res.content
                 with open(file_save_path, "wb") as file:
@@ -230,98 +238,105 @@ class Snapend:
                         json.dump(content, file, indent=4)
                     else:
                         file.write(res.content)
-                success(f"{self.category} saved at {file_save_path}")
                 return True
-            error(f'Unable to download {self.category}')
         except RequestException as e:
-            error(
+            info(
                 f"Exception: Unable to download {self.category}. Reason: {e}"
             )
         return False
 
-    def validate_input(self) -> ResponseType:
+    # Validate input
+    def validate_input(self) -> None:
         """
           Validator
         """
-        response: ResponseType = {
-            'error': True,
-            'msg': '',
-            'data': []
-        }
         # Check API Key and Base URL
         if not self.api_key or self.base_url == '':
-            response['msg'] = "Missing API Key."
-            return response
+            snapctl_error("Missing API Key.", SNAPCTL_INPUT_ERROR)
         # Check subcommand
         if not self.subcommand in Snapend.SUBCOMMANDS:
-            response['msg'] = \
-                f"Invalid command. Valid commands are {', '.join(Snapend.SUBCOMMANDS)}."
-            return response
+            snapctl_error(
+                f"Invalid command. Valid commands are {', '.join(Snapend.SUBCOMMANDS)}.",
+                SNAPCTL_INPUT_ERROR
+            )
         if self.subcommand == 'enumerate':
             if not self.game_id:
-                response['msg'] = "Missing required parameter: game_id"
-                return response
+                snapctl_error("Missing required parameter: game_id",
+                              SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'clone':
             if not self.game_id:
-                response['msg'] = "Missing required parameter: game_id"
-                return response
+                snapctl_error("Missing required parameter: game_id",
+                              SNAPCTL_INPUT_ERROR)
             if not self.name:
-                response['msg'] = "Missing required parameter: name"
-                return response
+                snapctl_error("Missing required parameter: name",
+                              SNAPCTL_INPUT_ERROR)
             if self.env.upper() not in Snapend.ENV_TYPES:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid environment. Valid environments are "
-                    f"{', '.join(Snapend.ENV_TYPES)}."
+                    f"{', '.join(Snapend.ENV_TYPES)}.",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
             if not self.manifest_path:
-                response['msg'] = "Missing required parameter: manifest_path"
-                return response
+                snapctl_error(
+                    "Missing required parameter: manifest_path", SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'apply':
             if not self.manifest_path:
-                response['msg'] = "Missing required parameter: manifest_path"
-                return response
+                snapctl_error(
+                    "Missing required parameter: manifest_path", SNAPCTL_INPUT_ERROR)
+                raise typer.Exit(code=SNAPCTL_INPUT_ERROR)
             if not self.manifest_file_name:
-                response['msg'] = "Invalid manifest file. Supported formats are .json, .yml, .yaml"
-                return response
+                snapctl_error(
+                    "Invalid manifest file. Supported formats are .json, .yml, .yaml",
+                    SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'download':
+            if not self.snapend_id:
+                snapctl_error(
+                    "Missing required parameter: snapend_id", SNAPCTL_INPUT_ERROR)
+            if not self.category:
+                snapctl_error(
+                    "Missing required parameter: category", SNAPCTL_INPUT_ERROR)
             if self.category not in Snapend.DOWNLOAD_CATEGORY:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid SDK category. Valid categories are "
-                    f"{', '.join(Snapend.DOWNLOAD_CATEGORY)}."
+                    f"{', '.join(Snapend.DOWNLOAD_CATEGORY)}.",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
             if self.category not in Snapend.DOWNLOAD_TYPE_NOT_REQUIRED and \
                     (self.download_types is None or self.platform_type not in self.download_types):
-                response['msg'] = "Invalid Download type."
-                return response
-            # Check file path
-            if self.out_path and not os.path.isdir(f"{self.out_path}"):
-                response['msg'] = (
-                    f"Invalid path {self.out_path}. "
-                    "Please enter a valid path to save your output file"
-                )
-                return response
+                snapctl_error("Invalid Download type.", SNAPCTL_INPUT_ERROR)
             # Check the Protos category
             if self.category == 'protos' and self.protos_category not in Snapend.PROTOS_CATEGORY:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid Protos category. Valid categories are "
-                    f"{', '.join(Snapend.PROTOS_CATEGORY)}."
+                    f"{', '.join(Snapend.PROTOS_CATEGORY)}.",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
             # Check the auth type
             if self.category == 'server-sdk' and self.auth_type not in Snapend.AUTH_TYPES:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid auth type. Valid auth types are "
-                    f"{', '.join(Snapend.AUTH_TYPES)}."
+                    f"{', '.join(Snapend.AUTH_TYPES)}.",
+                    SNAPCTL_INPUT_ERROR
+                )
+            # Check file path
+            if not self.out_path:
+                snapctl_error("Missing required parameter: out-path",
+                              SNAPCTL_INPUT_ERROR)
+            if self.out_path and not os.path.isdir(f"{self.out_path}"):
+                snapctl_error(
+                    f"Invalid path {self.out_path}. "
+                    "Please enter a valid path to save your output file",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
         elif self.subcommand == 'promote':
             if not self.snapend_id:
-                response['msg'] = "Missing required parameter: snapend_id"
-                return response
+                snapctl_error(
+                    "Missing required parameter: snapend_id", SNAPCTL_INPUT_ERROR)
         # Check update commands
         elif self.subcommand == 'update':
+            if not self.snapend_id:
+                snapctl_error(
+                    "Missing required parameter: snapend_id", SNAPCTL_INPUT_ERROR)
             byosnap_present = True
             if self.byosnap_list is None or len(self.byosnap_list) == 0:
                 byosnap_present = False
@@ -329,283 +344,348 @@ class Snapend:
             if self.byogs_list is None or len(self.byogs_list) == 0:
                 byogs_present = False
             if not byosnap_present and not byogs_present:
-                response['msg'] = "The update command needs one of byosnaps or byogs"
-                return response
-        # Send success
-        response['error'] = False
-        return response
+                snapctl_error(
+                    "The update command needs one of byosnaps or byogs", SNAPCTL_INPUT_ERROR)
 
     ## Subcommands ##
-    def enumerate(self) -> bool:
+    def enumerate(self) -> None:
         """
           List Snapends
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Enumerating all your game snapends...', total=None)
-            try:
-                url = f"{self.base_url}/v1/snapser-api/snapends?game_id={self.game_id}"
-                res = requests.get(
-                    url, headers={'api-key': self.api_key},
-                    timeout=SERVER_CALL_TIMEOUT
-                )
-                response_json = res.json()
-                if res.ok:
-                    if 'clusters' in response_json:
-                        success(response_json['clusters'])
-                        return True
-                error(response_json)
-            except RequestException as e:
-                error(f"Exception: Unable to update your snapend {e}")
-            return False
+        )
+        progress.start()
+        progress.add_task(
+            description='Enumerating all your game snapends...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/snapends?game_id={self.game_id}"
+            res = requests.get(
+                url, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            response_json = res.json()
+            if res.ok and 'clusters' in response_json:
+                snapctl_success(response_json['clusters'], progress)
+        except RequestException:
+            snapctl_error("Snapctl Exception. Unable to enumerate snapends.",
+                          SNAPCTL_SNAPEND_ENUMERATE_ERROR, progress)
+        snapctl_error("Unable to enumerate snapends.",
+                      SNAPCTL_SNAPEND_ENUMERATE_ERROR, progress)
 
-    def clone(self) -> bool:
+    def clone(self) -> None:
         """
           Create a Snapend from a manifest
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Applying your manifest...', total=None)
-            try:
-                with open(self.manifest_path, 'rb') as file:
-                    files = {'snapend-manifest': file}
-                    payload = {
-                        'game_id': self.game_id,
-                        'name': self.name,
-                        'env': self.env.upper(),
-                        'ext': self.manifest_file_name.split('.')[-1]
-                    }
-                    url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
-                    res = requests.post(
-                        url, headers={'api-key': self.api_key},
-                        files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
-                    )
-                    if res.ok:
-                        # extract the cluster ID
-                        response = res.json()
-                        if 'cluster' not in response or 'id' not in response['cluster']:
-                            error(
-                                'Something went wrong. Please try again in sometime.'
-                            )
-                            return False
-                        self._assign_snapend_id(response['cluster']['id'])
-                        info(
-                            f"Cluster ID assigned: {response['cluster']['id']}")
-                        if self.blocking:
-                            status = self._blocking_get_status()
-                            # Fetch the new manifest
-                            if status is True:
-                                # TODO: Uncomment this if we want to do an auto download
-                                # self._setup_for_download(
-                                #     self.manifest_file_name.split('.')[-1])
-                                # self._execute_download()
-                                info(
-                                    'Do not forget to download the latest manifest.'
-                                )
-                                return True
-                            info(
-                                'Snapend clone has been initiated but the Snapend is not up yet.'
-                                'Please try checking the status of the Snapend in some time'
-                            )
-                            return False
-                        info(
-                            "Snapend clone has been initiated. "
-                            "You can check the status using "
-                            f"`snapctl snapend state --snapend-id {response['cluster']['id']}`"
+        )
+        progress.start()
+        progress.add_task(
+            description='Cloning your snapend from the manifest...', total=None)
+        try:
+            with open(self.manifest_path, 'rb') as file:
+                files = {'snapend-manifest': file}
+                payload = {
+                    'game_id': self.game_id,
+                    'name': self.name,
+                    'env': self.env.upper(),
+                    'ext': self.manifest_file_name.split('.')[-1]
+                }
+                url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
+                res = requests.post(
+                    url, headers={'api-key': self.api_key},
+                    files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
+                )
+                if res.ok:
+                    # extract the cluster ID
+                    response = res.json()
+                    if 'cluster' not in response or 'id' not in response['cluster']:
+                        snapctl_error(
+                            'Server Error. Unable to get a Snapend ID. '
+                            'Please try again in sometime.',
+                            SNAPCTL_SNAPEND_CLONE_SERVER_ERROR,
+                            progress
+                        )
+                    self._assign_snapend_id(response['cluster']['id'])
+                    info(
+                        f"Cluster ID assigned: {response['cluster']['id']}")
+                    if self.blocking:
+                        status = self._blocking_get_status()
+                        # Fetch the new manifest
+                        if status is True:
+                            # TODO: Uncomment this if we want to do an auto download
+                            # self._setup_for_download(
+                            #     self.manifest_file_name.split('.')[-1])
+                            # self._execute_download()
+                            snapctl_success(
+                                'Snapend clone successful. Do not forget to download the latest manifest.',
+                                progress)
+                        snapctl_error(
+                            'Snapend clone has been initiated but the Snapend is not up yet.'
+                            'Please try checking the status of the Snapend in some time',
+                            SNAPCTL_SNAPEND_CLONE_TIMEOUT_ERROR,
+                            progress
                         )
-                        return True
-                    error('Unable to apply the manifest. Reason: ' + res.text)
-            except RequestException as e:
-                error(f"Exception: Unable to apply the manifest snapend {e}")
-            return False
+                    snapctl_success(
+                        "Snapend clone has been initiated. "
+                        "You can check the status using "
+                        f"`snapctl snapend state --snapend-id {response['cluster']['id']}`",
+                        progress
+                    )
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to apply the manifest snapend. {e}",
+                SNAPCTL_SNAPEND_CLONE_ERROR, progress
+            )
+        snapctl_error('Unable to apply the manifest.',
+                      SNAPCTL_SNAPEND_CLONE_ERROR, progress)
 
-    def apply(self) -> bool:
+    def apply(self) -> None:
         """
           Apply a manifest
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Applying your manifest...', total=None)
-            try:
-                with open(self.manifest_path, 'rb') as file:
-                    files = {'snapend-manifest': file}
-                    payload = {
-                        'ext': self.manifest_file_name.split('.')[-1]
-                    }
-                    url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
-                    res = requests.put(
-                        url, headers={'api-key': self.api_key},
-                        files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
-                    )
-                    if res.ok:
-                        # extract the cluster ID
-                        response = res.json()
-                        if 'cluster' not in response or 'id' not in response['cluster']:
-                            error(
-                                'Something went wrong. Please try again in sometime.'
-                            )
-                            return False
-                        self._assign_snapend_id(response['cluster']['id'])
-                        if self.blocking:
-                            status = self._blocking_get_status()
-                            # Fetch the new manifest
-                            if status is True:
-                                # TODO: Uncomment this if we want to do an auto download
-                                # self._setup_for_download(
-                                #     self.manifest_file_name.split('.')[-1])
-                                # self._execute_download()
-                                info(
-                                    'Do not forget to download the latest manifest.'
-                                )
-                                return True
-                            info(
-                                'Snapend apply has been initiated but the Snapend is not up yet.'
-                                'Please try checking the status of the Snapend in some time'
-                            )
-                            return False
-                        info(
-                            "Snapend apply has been initiated. "
-                            "You can check the status using "
-                            f"`snapctl snapend state --snapend-id {response['cluster']['id']}`"
+        )
+        progress.start()
+        progress.add_task(
+            description='Applying your manifest...', total=None)
+        try:
+            with open(self.manifest_path, 'rb') as file:
+                files = {'snapend-manifest': file}
+                payload = {
+                    'ext': self.manifest_file_name.split('.')[-1]
+                }
+                url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
+                res = requests.put(
+                    url, headers={'api-key': self.api_key},
+                    files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
+                )
+                if res.ok:
+                    # extract the cluster ID
+                    response = res.json()
+                    if 'cluster' not in response or 'id' not in response['cluster']:
+                        snapctl_error(
+                            'Server Error. Unable to get a Snapend ID. '
+                            'Please try again in sometime.',
+                            SNAPCTL_SNAPEND_APPLY_SERVER_ERROR,
+                            progress
                         )
-                        return True
-                    error('Unable to apply the manifest. Reason: ' + res.text)
-            except RequestException as e:
-                error(f"Exception: Unable to apply the manifest snapend {e}")
-            return False
+                    self._assign_snapend_id(response['cluster']['id'])
+                    if self.blocking:
+                        status = self._blocking_get_status()
+                        # Fetch the new manifest
+                        if status is True:
+                            # TODO: Uncomment this if we want to do an auto download
+                            # self._setup_for_download(
+                            #     self.manifest_file_name.split('.')[-1])
+                            # self._execute_download()
+                            snapctl_success(
+                                'Snapend apply successful. Do not forget to download '
+                                'the latest manifest.',
+                                progress)
+                        snapctl_error(
+                            'Snapend apply has been initiated but the Snapend is not up yet.'
+                            'Please try checking the status of the Snapend in some time',
+                            SNAPCTL_SNAPEND_APPLY_TIMEOUT_ERROR, progress
+                        )
+                    snapctl_success(
+                        "Snapend apply has been initiated. "
+                        "You can check the status using "
+                        f"`snapctl snapend state --snapend-id {response['cluster']['id']}`",
+                        progress
+                    )
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to apply the manifest snapend. {e}",
+                SNAPCTL_SNAPEND_APPLY_ERROR, progress
+            )
+        snapctl_error(
+            'Unable to apply the manifest.', SNAPCTL_SNAPEND_APPLY_ERROR, progress)
 
-    def promote(self) -> bool:
+    def promote(self) -> None:
         """
           Promote a staging manifest to production
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Promoting your staging snapend...', total=None)
-            try:
-                with open(self.manifest_path, 'rb') as file:
-                    payload = {
-                        'snapend_id': self.snapend_id
-                    }
-                    url = f"{self.base_url}/v1/snapser-api/snapends/promote"
-                    res = requests.put(
-                        url, headers={'api-key': self.api_key},
-                        json=payload, timeout=SERVER_CALL_TIMEOUT
-                    )
-                    if res.ok:
-                        # extract the cluster ID
-                        response = res.json()
-                        if 'cluster' not in response or 'id' not in response['cluster']:
-                            error(
-                                'Something went wrong. Please try again in sometime.'
-                            )
-                            return False
-                        self._assign_snapend_id(response['cluster']['id'])
-                        if self.blocking:
-                            status = self._blocking_get_status()
-                            if status is True:
-                                # TODO: Uncomment this if we want to do an auto download
-                                # self._setup_for_download(
-                                #     self.manifest_file_name.split('.')[-1])
-                                # self._execute_download()
-                                # Fetch the new manifest
-                                info(
-                                    'Do not forget to download the latest manifest.'
-                                )
-                                return True
-                            info(
-                                'Snapend apply has been initiated but the Snapend is not up yet.'
-                                'Please try checking the status of the Snapend in some time'
+        )
+        progress.start()
+        progress.add_task(
+            description='Promoting your staging snapend...', total=None)
+        try:
+            with open(self.manifest_path, 'rb') as file:
+                payload = {
+                    'snapend_id': self.snapend_id
+                }
+                url = f"{self.base_url}/v1/snapser-api/snapends/promote"
+                res = requests.put(
+                    url, headers={'api-key': self.api_key},
+                    json=payload, timeout=SERVER_CALL_TIMEOUT
+                )
+                if res.ok:
+                    # extract the cluster ID
+                    response = res.json()
+                    if 'cluster' not in response or 'id' not in response['cluster']:
+                        snapctl_error(
+                            'Server Error. Unable to get a Snapend ID. '
+                            'Please try again in sometime.',
+                            SNAPCTL_SNAPEND_PROMOTE_SERVER_ERROR,
+                            progress
+                        )
+                    self._assign_snapend_id(response['cluster']['id'])
+                    if self.blocking:
+                        status = self._blocking_get_status()
+                        if status is True:
+                            # TODO: Uncomment this if we want to do an auto download
+                            # self._setup_for_download(
+                            #     self.manifest_file_name.split('.')[-1])
+                            # self._execute_download()
+                            # Fetch the new manifest
+                            snapctl_success(
+                                'Snapend promote successful. Do not forget to '
+                                'download the latest manifest.',
+                                progress
                             )
-                            return False
-                        info(
-                            "Snapend apply has been initiated. "
-                            "You can check the status using "
-                            f"`snapctl snapend state --snapend-id {response['cluster']['id']}`"
+                        snapctl_error(
+                            'Snapend apply has been initiated but the Snapend is not up yet.'
+                            'Please try checking the status of the Snapend in some time',
+                            SNAPCTL_SNAPEND_PROMOTE_TIMEOUT_ERROR,
+                            progress
                         )
-                        return True
-                    error('Unable to promote the manifest. Reason: ' + res.text)
-            except RequestException as e:
-                error(f"Exception: Unable to apply the manifest snapend {e}")
-            return False
+                    snapctl_success(
+                        "Snapend apply has been initiated. "
+                        "You can check the status using "
+                        f"`snapctl snapend state --snapend-id {response['cluster']['id']}`",
+                        progress
+                    )
+                snapctl_error(f'Unable to promote the manifest. Reason: {res.text}',
+                              SNAPCTL_SNAPEND_PROMOTE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to promote the snapend. {e}",
+                SNAPCTL_SNAPEND_PROMOTE_ERROR, progress
+            )
+        snapctl_error("Unable to promote the snapend.",
+                      SNAPCTL_SNAPEND_PROMOTE_ERROR, progress)
 
-    def download(self) -> bool:
+    def download(self) -> None:
         """
           Download SDKs, Protos, Admin Settings and Configuration
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description=f'Downloading your Custom {self.category}...', total=None)
-            return self._execute_download()
+        )
+        progress.start()
+        progress.add_task(
+            description=f'Downloading your Custom {self.category}...', total=None)
+        try:
+            if self._execute_download():
+                snapctl_success(
+                    f"Snapend download successful. {self.category} saved at {self.out_path}",
+                    progress
+                )
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to download {self.category}. Reason: {e}",
+                SNAPCTL_SNAPEND_DOWNLOAD_ERROR, progress
+            )
+        snapctl_error(f"Unable to download {self.category}",
+                      SNAPCTL_SNAPEND_DOWNLOAD_ERROR, progress)
 
-    def update(self) -> bool:
+    def update(self) -> None:
         """
           Update a Snapend
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Updating your Snapend...', total=None)
-            try:
-                payload = {
-                    'byosnap_updates': self.byosnap_list,
-                    'byogs_updates': self.byogs_list
-                }
-                url = f"{self.base_url}/v1/snapser-api/snapends/{self.snapend_id}"
-                res = requests.patch(
-                    url, json=payload, headers={'api-key': self.api_key},
-                    timeout=SERVER_CALL_TIMEOUT
-                )
-                if res.ok:
-                    if self.blocking:
-                        return self._blocking_get_status()
-                    success(
+        )
+        progress.start()
+        progress.add_task(
+            description='Updating your Snapend...', total=None)
+        try:
+            payload = {
+                'byosnap_updates': self.byosnap_list,
+                'byogs_updates': self.byogs_list
+            }
+            url = f"{self.base_url}/v1/snapser-api/snapends/{self.snapend_id}"
+            res = requests.patch(
+                url, json=payload, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            if res.ok:
+                if self.blocking:
+                    status = self._blocking_get_status()
+                    # Fetch the new manifest
+                    if status is True:
+                        # TODO: Uncomment this if we want to do an auto download
+                        # self._setup_for_download(
+                        #     self.manifest_file_name.split('.')[-1])
+                        # self._execute_download()
+                        snapctl_success(
+                            'Snapend update successful. Do not forget to '
+                            'download the latest manifest.',
+                            progress
+                        )
+                    snapctl_error(
                         'Snapend update has been initiated. '
-                        'You can check the status using `snapctl snapend state`'
+                        'You can check the status using `snapctl snapend state`',
+                        SNAPCTL_SNAPEND_UPDATE_TIMEOUT_ERROR,
+                        progress
                     )
-                    return True
-                response_json = res.json()
-                error(response_json['details'][0])
-            except RequestException as e:
-                error(f"Exception: Unable to update your snapend {e}")
-            return False
+                snapctl_success(
+                    "Snapend update has been initiated. "
+                    "You can check the status using "
+                    f"`snapctl snapend state --snapend-id {self.snapend_id}`",
+                    progress
+                )
+            snapctl_error(f"Unable to update the snapend. Reason: {res.text}",
+                          SNAPCTL_SNAPEND_UPDATE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to update the snapend {e}",
+                SNAPCTL_SNAPEND_UPDATE_ERROR, progress
+            )
+        snapctl_error("Unable to update the snapend.",
+                      SNAPCTL_SNAPEND_UPDATE_ERROR, progress)
 
-    def state(self) -> bool:
+    def state(self) -> None:
         """
           Get the state of a Snapend
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Getting your Snapend state...', total=None)
+        )
+        progress.start()
+        progress.add_task(
+            description='Getting your Snapend state...', total=None)
+        try:
             current_state = self._get_snapend_state()
             if current_state != 'INVALID':
-                success('Current snapend state is: ' + current_state)
-                return True
-            error("Unable to get the snapend state.")
-            return False
+                snapctl_success(
+                    f'Snapend get state successful. Current snapend state is: {current_state}',
+                    progress)
+            snapctl_error("Unable to get the snapend state.",
+                          SNAPCTL_SNAPEND_STATE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(
+                f"Unable to get your snapend state {e}",
+                SNAPCTL_SNAPEND_STATE_ERROR, progress
+            )
+        snapctl_error("Unable to get the snapend state.",
+                      SNAPCTL_SNAPEND_STATE_ERROR, progress)