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

snapctl/commands/byosnap.py

@@ -14,11 +14,16 @@ from requests.exceptions import RequestException
 
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from snapctl.config.constants import SERVER_CALL_TIMEOUT
-from snapctl.config.constants import ERROR_SERVICE_VERSION_EXISTS, ERROR_TAG_NOT_AVAILABLE, \
-    ERROR_ADD_ON_NOT_ENABLED
-from snapctl.types.definitions import ResponseType
-from snapctl.utils.echo import error, success, info
-from snapctl.utils.helper import get_composite_token
+from snapctl.config.constants import HTTP_ERROR_SERVICE_VERSION_EXISTS, \
+    HTTP_ERROR_TAG_NOT_AVAILABLE, HTTP_ERROR_ADD_ON_NOT_ENABLED, SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_BYOSNAP_DEPENDENCY_MISSING, SNAPCTL_BYOSNAP_ECR_LOGIN_ERROR, \
+    SNAPCTL_BYOSNAP_BUILD_ERROR, SNAPCTL_BYOSNAP_TAG_ERROR, SNAPCTL_BYOSNAP_PUBLISH_IMAGE_ERROR, \
+    SNAPCTL_BYOSNAP_PUBLISH_IMAGE_DUPLICATE_TAG_ERROR, \
+    SNAPCTL_BYOSNAP_CREATE_DUPLICATE_NAME_ERROR, SNAPCTL_BYOSNAP_CREATE_PERMISSION_ERROR, \
+    SNAPCTL_BYOSNAP_CREATE_ERROR, SNAPCTL_BYOSNAP_PUBLISH_VERSION_DUPLICATE_TAG_ERROR, \
+    SNAPCTL_BYOSNAP_PUBLISH_VERSION_ERROR
+from snapctl.utils.echo import success, info
+from snapctl.utils.helper import get_composite_token, snapctl_error, snapctl_success
 
 
 class ByoSnap:
@@ -27,20 +32,21 @@ class ByoSnap:
     """
     ID_PREFIX = 'byosnap-'
     SUBCOMMANDS = [
-        'build', 'push', 'upload-docs',
-        'create', 'publish-image', 'publish-version',
+        'create', 'publish-image', 'publish-version', 'upload-docs',
     ]
     PLATFORMS = ['linux/arm64', 'linux/amd64']
     LANGUAGES = ['go', 'python', 'ruby', 'c#', 'c++', 'rust', 'java', 'node']
     DEFAULT_BUILD_PLATFORM = 'linux/arm64'
     SID_CHARACTER_LIMIT = 47
     TAG_CHARACTER_LIMIT = 80
+    VALID_CPU_MARKS = [100, 250, 500, 750, 1000, 1500, 2000, 3000]
+    VALID_MEMORY_MARKS = [0.125, 0.25, 0.5, 1, 2, 3, 4]
 
     def __init__(
         self, subcommand: str, base_url: str, api_key: str | None, sid: str, name: str,
         desc: str, platform_type: str, language: str, input_tag: Union[str, None],
         path: Union[str, None], dockerfile: str, prefix: str, version: Union[str, None],
-        http_port: Union[int, None]
+        http_port: Union[int, None], byosnap_profile: Union[str, None]
     ) -> None:
         self.subcommand: str = subcommand
         self.base_url: str = base_url
@@ -65,6 +71,9 @@ class ByoSnap:
         self.prefix: str = prefix
         self.version: Union[str, None] = version
         self.http_port: Union[int, None] = http_port
+        self.byosnap_profile: Union[str, None] = byosnap_profile
+        # Validate the input
+        self.validate_input()
 
     # Protected methods
     @staticmethod
@@ -89,155 +98,156 @@ class ByoSnap:
             pass
         return None
 
-    def _check_dependencies(self) -> bool:
+    def _check_dependencies(self) -> None:
         """
           Check application dependencies
         """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Checking dependencies...', total=None)
         try:
             # Check dependencies
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Checking dependencies...', total=None)
-                try:
-                    subprocess.run([
-                        "docker", "--version"
-                    ], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
-                except subprocess.CalledProcessError:
-                    error('Docker not present')
-                    return False
-            success('Dependencies Verified')
-            return True
+            result = subprocess.run([
+                "docker", "info"
+            ], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
+            if not result.returncode:
+                return snapctl_success('BYOSnap dependencies verified',
+                                       progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('Unable to initialize docker')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOSNAP_DEPENDENCY_MISSING, progress)
+        snapctl_error('Docker not running. Please start docker.',
+                      SNAPCTL_BYOSNAP_DEPENDENCY_MISSING, progress)
 
-    def _docker_login(self) -> bool:
+    def _docker_login(self) -> None:
         """
           Docker Login
         """
         ecr_repo_url = self.token_parts[0]
         ecr_repo_username = self.token_parts[1]
         ecr_repo_token = self.token_parts[2]
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Logging into Snapser Image Registry...', total=None)
         try:
             # Login to Snapser Registry
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Logging into Snapser Image Registry...', total=None)
-                if platform == 'win32':
-                    response = subprocess.run([
-                        'docker', 'login', '--username', ecr_repo_username,
-                        '--password', ecr_repo_token, ecr_repo_url
-                    ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
-                else:
-                    response = subprocess.run([
-                        f'echo "{ecr_repo_token}" | docker login '
-                        f'--username {ecr_repo_username} --password-stdin {ecr_repo_url}'
-                    ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
-                if response.returncode:
-                    error(
-                        f'{response.returncode} - '
-                        'Unable to connect to the Snapser Container Repository. '
-                        'Please confirm if docker is running or try restarting docker'
-                    )
-                    return False
-            success('Login Successful')
-            return True
+            if platform == 'win32':
+                response = subprocess.run([
+                    'docker', 'login', '--username', ecr_repo_username,
+                    '--password', ecr_repo_token, ecr_repo_url
+                ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
+            else:
+                response = subprocess.run([
+                    f'echo "{ecr_repo_token}" | docker login '
+                    f'--username {ecr_repo_username} --password-stdin {ecr_repo_url}'
+                ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
+            if not response.returncode:
+                return snapctl_success('BYOSnap ECR login successful',
+                                       progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('Unable to initialize docker')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOSNAP_ECR_LOGIN_ERROR, progress)
+        snapctl_error('BYOSnap ECR login failure',
+                      SNAPCTL_BYOSNAP_ECR_LOGIN_ERROR, progress)
 
-    def _docker_build(self) -> bool:
+    def _docker_build(self) -> None:
         # Get the data
         image_tag = f'{self.sid}.{self.input_tag}'
         build_platform = ByoSnap.DEFAULT_BUILD_PLATFORM
         if len(self.token_parts) == 4:
             build_platform = self.token_parts[3]
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Building your snap...', total=None)
         try:
             # Build your snap
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Building your snap...', total=None)
-                docker_file_path = f"{self.path}/{self.dockerfile}"
-                if platform == "win32":
-                    response = subprocess.run([
-                        # f"docker build --no-cache -t {tag} {path}"
-                        'docker', 'build', '--platform', build_platform, '-t', image_tag,
-                        '-f', docker_file_path,  self.path
-                    ], shell=True, check=False)
-                    # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
-                else:
-                    response = subprocess.run([
-                        # f"docker build --no-cache -t {tag} {path}"
-                        f"docker build --platform {build_platform} -t {image_tag} -f {docker_file_path} {self.path}"
-                    ], shell=True, check=False)
-                    # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
-                if response.returncode:
-                    error('Unable to build docker')
-                    return False
-            success('Build Successful')
-            return True
+            docker_file_path = os.path.join(self.path, self.dockerfile)
+            if platform == "win32":
+                response = subprocess.run([
+                    # f"docker build --no-cache -t {tag} {path}"
+                    'docker', 'build', '--platform', build_platform, '-t', image_tag,
+                    '-f', docker_file_path,  self.path
+                ], shell=True, check=False)
+                # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            else:
+                response = subprocess.run([
+                    # f"docker build --no-cache -t {tag} {path}"
+                    f"docker build --platform {build_platform} -t {image_tag} "
+                    f"-f {docker_file_path} {self.path}"
+                ], shell=True, check=False)
+                # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            if not response.returncode:
+                return snapctl_success('BYOSnap build successful',
+                                       progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOSNAP_BUILD_ERROR, progress)
+        snapctl_error('BYOSnap build failure',
+                      SNAPCTL_BYOSNAP_BUILD_ERROR, progress)
 
-    def _docker_tag(self) -> bool:
+    def _docker_tag(self) -> None:
         # Get the data
         ecr_repo_url = self.token_parts[0]
         image_tag = f'{self.sid}.{self.input_tag}'
         full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Tagging your snap...', total=None)
         try:
             # Tag the repo
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Tagging your snap...', total=None)
-                if platform == "win32":
-                    response = subprocess.run([
-                        'docker', 'tag', image_tag, full_ecr_repo_url
-                    ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
-                else:
-                    response = subprocess.run([
-                        f"docker tag {image_tag} {full_ecr_repo_url}"
-                    ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
-                if response.returncode:
-                    error('Unable to tag your snap')
-                    return False
-            success('Tag Successful')
-            return True
+            if platform == "win32":
+                response = subprocess.run([
+                    'docker', 'tag', image_tag, full_ecr_repo_url
+                ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
+            else:
+                response = subprocess.run([
+                    f"docker tag {image_tag} {full_ecr_repo_url}"
+                ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
+            if not response.returncode:
+                return snapctl_success('BYOSnap tag successful',
+                                       progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOSNAP_TAG_ERROR, progress)
+        snapctl_error('BYOSnap tag failure',
+                      SNAPCTL_BYOSNAP_TAG_ERROR, progress)
 
     def _docker_push(self) -> bool:
         """
           Push the Snap image
         """
-        ecr_repo_url = self.token_parts[0]
-        image_tag = f'{self.sid}.{self.input_tag}'
-        full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
-
-        # Push the image
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(description='Pushing your snap...', total=None)
+        )
+        progress.start()
+        progress.add_task(description='Pushing your snap...', total=None)
+        try:
+            # Push the image
+            ecr_repo_url = self.token_parts[0]
+            image_tag = f'{self.sid}.{self.input_tag}'
+            full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
             if platform == "win32":
                 response = subprocess.run([
                     'docker', 'push', full_ecr_repo_url
@@ -248,133 +258,192 @@ class ByoSnap:
                     f"docker push {full_ecr_repo_url}"
                 ], shell=True, check=False)
                 # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
-            if response.returncode:
-                error('Unable to push your snap')
-                return False
-        success('Snap Upload Successful')
-        return True
+            if not response.returncode:
+                return snapctl_success('BYOSnap upload successful',
+                                       progress, no_exit=True)
+        except subprocess.CalledProcessError:
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOSNAP_PUBLISH_IMAGE_ERROR, progress)
+        snapctl_error('BYOSnap upload failure. Duplicate image error.',
+                      SNAPCTL_BYOSNAP_PUBLISH_IMAGE_DUPLICATE_TAG_ERROR, progress)
+
+    def _validate_byosnap_profile(self) -> None:
+        """
+          Validate the BYOSnap profile
+        """
+        if not self.byosnap_profile:
+            snapctl_error("Missing BYOSnap profile path", SNAPCTL_INPUT_ERROR)
+        if not os.path.isfile(self.byosnap_profile):
+            snapctl_error(
+                "Unable to find BYOSnap profile "
+                F"JSON at path {self.byosnap_profile}",
+                SNAPCTL_INPUT_ERROR
+            )
+        profile_data = None
+        with open(self.byosnap_profile, 'rb') as file:
+            try:
+                profile_data = json.load(file)
+            except json.JSONDecodeError:
+                pass
+        if not profile_data:
+            snapctl_error(
+                'Invalid BYOSnap profile JSON. Please check the JSON structure',
+                SNAPCTL_INPUT_ERROR
+            )
+        if 'dev_template' not in profile_data or \
+            'stage_template' not in profile_data or \
+                'prod_template' not in profile_data:
+            snapctl_error(
+                'Invalid BYOSnap profile JSON. Please check the JSON structure',
+                SNAPCTL_INPUT_ERROR
+            )
+        for profile in ['dev_template', 'stage_template', 'prod_template']:
+            if 'cpu' not in profile_data[profile] or \
+                'memory' not in profile_data[profile] or \
+                    'cmd' not in profile_data[profile] or \
+                    'args' not in profile_data[profile] or \
+                    'env_params' not in profile_data[profile]:
+                snapctl_error(
+                    'Invalid BYOSnap profile JSON. Please check the JSON structure',
+                    SNAPCTL_INPUT_ERROR
+                )
+            if profile_data[profile]['cpu'] not in ByoSnap.VALID_CPU_MARKS:
+                snapctl_error(
+                    'Invalid CPU value in BYOSnap profile. '
+                    f'Valid values are {", ".join(map(str, ByoSnap.VALID_CPU_MARKS))}',
+                    SNAPCTL_INPUT_ERROR
+                )
+            if profile_data[profile]['memory'] not in ByoSnap.VALID_MEMORY_MARKS:
+                snapctl_error(
+                    'Invalid Memory value in BYOSnap profile. '
+                    f'Valid values are {", ".join(map(str, ByoSnap.VALID_MEMORY_MARKS))}',
+                    SNAPCTL_INPUT_ERROR
+                )
 
     # Public methods
 
     # Validator
-    def validate_input(self) -> ResponseType:
+    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 ByoSnap.SUBCOMMANDS:
-            response['msg'] = (
-                "Invalid command. Valid commands ",
-                f"are {', '.join(ByoSnap.SUBCOMMANDS)}."
+            snapctl_error(
+                "Invalid command. Valid commands "
+                f"are {', '.join(ByoSnap.SUBCOMMANDS)}.",
+                SNAPCTL_INPUT_ERROR
             )
-            return response
         # Validate the SID
         if not self.sid.startswith(ByoSnap.ID_PREFIX):
-            response['msg'] = f"Invalid Snap ID. Valid Snap IDs start with {ByoSnap.ID_PREFIX}."
-            return response
+            snapctl_error(
+                f"Invalid Snap ID. Valid Snap IDs start with {ByoSnap.ID_PREFIX}.",
+                SNAPCTL_INPUT_ERROR
+            )
         if len(self.sid) > ByoSnap.SID_CHARACTER_LIMIT:
-            response['msg'] = (
+            snapctl_error(
                 "Invalid Snap ID. "
-                f"Snap ID should be less than {ByoSnap.SID_CHARACTER_LIMIT} characters"
+                f"Snap ID should be less than {ByoSnap.SID_CHARACTER_LIMIT} characters",
+                SNAPCTL_INPUT_ERROR
             )
-            return response
         # Validation for subcommands
         if self.subcommand == 'create':
             if self.name == '':
-                response['msg'] = "Missing name"
-                return response
+                snapctl_error("Missing name", SNAPCTL_INPUT_ERROR)
+            if not self.language:
+                snapctl_error("Missing language", SNAPCTL_INPUT_ERROR)
             if self.language not in ByoSnap.LANGUAGES:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid language. Valid languages are "
-                    f"{', '.join(ByoSnap.LANGUAGES)}."
+                    f"{', '.join(ByoSnap.LANGUAGES)}.",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
             if self.platform_type not in ByoSnap.PLATFORMS:
-                response['msg'] = (
+                snapctl_error(
                     "Invalid platform. Valid platforms are "
-                    f"{', '.join(ByoSnap.PLATFORMS)}."
+                    f"{', '.join(ByoSnap.PLATFORMS)}.",
+                    SNAPCTL_INPUT_ERROR
                 )
-                return response
         else:
             # Check the token
             if self.token_parts is None:
-                response['msg'] = 'Invalid token. Please reach out to your support team.'
-                return response
-            # Check tag
-            if self.input_tag is None or len(self.input_tag.split()) > 1 or \
-                    len(self.input_tag) > ByoSnap.TAG_CHARACTER_LIMIT:
-                response['msg'] = (
-                    "Tag should be a single word with maximum of "
-                    f"{ByoSnap.TAG_CHARACTER_LIMIT} characters"
-                )
-                return response
-            if self.subcommand == 'build' or self.subcommand == 'publish-image':
+                snapctl_error('Invalid token. Please reach out to your support team.',
+                              SNAPCTL_INPUT_ERROR)
+            if self.subcommand in ['build', 'publish-image']:
                 if not self.input_tag:
-                    response['msg'] = "Missing required parameter: tag"
-                    return response
+                    snapctl_error(
+                        "Missing required parameter: tag", SNAPCTL_INPUT_ERROR)
+                if len(self.input_tag.split()) > 1 or \
+                        len(self.input_tag) > ByoSnap.TAG_CHARACTER_LIMIT:
+                    snapctl_error(
+                        "Tag should be a single word with maximum of "
+                        f"{ByoSnap.TAG_CHARACTER_LIMIT} characters",
+                        SNAPCTL_INPUT_ERROR
+                    )
                 if not self.path:
-                    response['msg'] = "Missing required parameter: path"
-                    return response
+                    snapctl_error("Missing required parameter: path",
+                                  SNAPCTL_INPUT_ERROR)
                 # Check path
                 if not os.path.isfile(f"{self.path}/{self.dockerfile}"):
-                    response['msg'] = f"Unable to find {self.dockerfile} at path {self.path}"
-                    return response
-            elif self.subcommand == 'push':
-                if not self.input_tag:
-                    response['msg'] = "Missing required parameter: tag"
-                    return response
+                    snapctl_error(
+                        f"Unable to find {self.dockerfile} at path {self.path}",
+                        SNAPCTL_INPUT_ERROR)
+            # elif self.subcommand == 'push':
+            #     if not self.input_tag:
+            #         error("Missing required parameter: tag", SNAPCTL_INPUT_ERROR)
+            #         raise typer.Exit(code=SNAPCTL_INPUT_ERROR)
             elif self.subcommand == 'upload-docs':
                 if self.path is None:
-                    response['msg'] = "Missing required parameter: path"
-                    return response
+                    snapctl_error(
+                        "Missing required parameter: path", SNAPCTL_INPUT_ERROR)
             elif self.subcommand == 'publish-version':
-                if not self.prefix:
-                    response['msg'] = "Missing prefix"
-                    return response
-                if not self.version:
-                    response['msg'] = "Missing version"
-                    return response
-                if not self.http_port:
-                    response['msg'] = "Missing Ingress HTTP Port"
-                    return response
+                if not self.input_tag:
+                    snapctl_error(
+                        "Missing required parameter: tag", SNAPCTL_INPUT_ERROR)
+                if len(self.input_tag.split()) > 1 or len(self.input_tag) > ByoSnap.TAG_CHARACTER_LIMIT:
+                    snapctl_error(
+                        "Tag should be a single word with maximum of "
+                        f"{ByoSnap.TAG_CHARACTER_LIMIT} characters",
+                        SNAPCTL_INPUT_ERROR
+                    )
+                if not self.prefix or self.prefix == '':
+                    snapctl_error("Missing prefix", SNAPCTL_INPUT_ERROR)
                 if not self.prefix.startswith('/'):
-                    response['msg'] = "Prefix should start with a forward slash (/)"
-                    return response
+                    snapctl_error("Prefix should start with a forward slash (/)",
+                                  SNAPCTL_INPUT_ERROR)
                 if self.prefix.endswith('/'):
-                    response['msg'] = "Prefix should not end with a forward slash (/)"
-                    return response
+                    snapctl_error("Prefix should not end with a forward slash (/)",
+                                  SNAPCTL_INPUT_ERROR)
+                if not self.version:
+                    snapctl_error("Missing version", SNAPCTL_INPUT_ERROR)
                 pattern = r'^v\d+\.\d+\.\d+$'
                 if not re.match(pattern, self.version):
-                    response['msg'] = "Version should be in the format vX.X.X"
-                    return response
+                    snapctl_error("Version should be in the format vX.X.X",
+                                  SNAPCTL_INPUT_ERROR)
+                if not self.http_port:
+                    snapctl_error("Missing Ingress HTTP Port",
+                                  SNAPCTL_INPUT_ERROR)
                 if not self.http_port.isdigit():
-                    response['msg'] = "Ingress HTTP Port should be a number"
-                    return response
-        # Send success
-        response['error'] = False
-        return response
+                    snapctl_error("Ingress HTTP Port should be a number",
+                                  SNAPCTL_INPUT_ERROR)
+                # Check byosnap_profile path
+                self._validate_byosnap_profile()
 
     # CRUD methods
-    def build(self) -> bool:
+
+    def build(self) -> None:
         """
           Build the image
           1. Check Dependencies
           2. Login to Snapser Registry
           3. Build your snap
         """
-        if not self._check_dependencies() or not self._docker_login() or \
-                not self._docker_build():
-            return False
-        return True
+        self._check_dependencies()
+        self._docker_login()
+        self._docker_build()
 
     def push(self) -> bool:
         """
@@ -384,26 +453,29 @@ class ByoSnap:
           3. Tag the snap
           4. Push your snap
         """
-        if not self._check_dependencies() or not self._docker_login() or \
-                not self._docker_tag() or not self._docker_push():
-            return False
-        return True
+        self._check_dependencies()
+        self._docker_login()
+        self._docker_tag()
+        self._docker_push()
 
-    def upload_docs(self) -> bool:
+    # Upper echelon commands
+    def upload_docs(self) -> None:
         '''
-          Note this step is optional hence we always respond with a True
+          Note this step is optional hence we do not raise a typer.Exit
         '''
-        swagger_file = f"{self.path}/swagger.json"
-        readme_file = f"{self.path}/README.md"
-        if os.path.isfile(swagger_file):
-            # Push the swagger.json
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Uploading your API Json...', total=None)
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Uploading your BYOSnap Docs...', total=None)
+        try:
+            swagger_file = os.path.join(self.path, 'swagger.json')
+            readme_file = os.path.join(self.path, 'README.md')
+            if os.path.isfile(swagger_file):
+                # Push the swagger.json
                 try:
                     attachment_file = open(swagger_file, "rb")
                     url = (
@@ -418,25 +490,18 @@ class ByoSnap:
                     if test_res.ok:
                         success('Uploaded swagger.json')
                     else:
-                        error('Unable to upload your swagger.json')
+                        info('Unable to upload your swagger.json')
                 except RequestException as e:
                     info(
                         f'Exception: Unable to find swagger.json at {self.path} {e}'
                     )
-        else:
-            info('No swagger.json found at ' + self.path +
-                 '. Skipping swagger.json upload')
+            else:
+                info(f'No swagger.json found at {self.path}'
+                     '. Skipping swagger.json upload')
 
-        # Push the README.md
-        if os.path.isfile(readme_file):
-            # Push the swagger.json
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Uploading your README...', total=None)
+            # Push the README.md
+            if os.path.isfile(readme_file):
+                # Push the swagger.json
                 try:
                     attachment_file = open(readme_file, "rb")
                     url = (
@@ -451,67 +516,71 @@ class ByoSnap:
                     if test_res.ok:
                         success('Uploaded README.md')
                     else:
-                        error('Unable to upload your README.md')
+                        info('Unable to upload your README.md')
                 except RequestException as e:
                     info(
-                        f'Exception: Unable to find README.md at {self.path} {str(e)}'
-                    )
-        else:
-            info(
-                f'No README.md found at {self.path}. Skipping README.md upload'
-            )
-        return True
+                        f'Exception: Unable to find README.md at {self.path} {str(e)}')
+            else:
+                info(
+                    f'No README.md found at {self.path}. Skipping README.md upload')
+        except RequestException as e:
+            info(f'Exception: Unable to upload your API Json {str(e)}')
+        finally:
+            progress.stop()
+        # snapctl_success('BYOSnap upload successful', no_exit=no_exit)
 
-    # Upper echelon commands
-    def create(self) -> bool:
+    def create(self) -> None:
         """
           Creating a new snap
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(description='Creating your snap...', total=None)
-            try:
-                payload = {
-                    "service_id": self.sid,
-                    "name": self.name,
-                    "description": self.desc,
-                    "platform": self.platform_type,
-                    "language": self.language,
-                }
-                res = requests.post(
-                    f"{self.base_url}/v1/snapser-api/byosnaps",
-                    json=payload, headers={'api-key': self.api_key},
-                    timeout=SERVER_CALL_TIMEOUT
-                )
-                if res.ok:
-                    return True
-                response_json = res.json()
-                info(response_json)
-                if "api_error_code" in response_json and "message" in response_json:
-                    if response_json['api_error_code'] == ERROR_SERVICE_VERSION_EXISTS:
-                        error(
-                            'Version already exists. Please update your version and try again'
-                        )
-                    elif response_json['api_error_code'] == ERROR_TAG_NOT_AVAILABLE:
-                        error('Invalid tag. Please use the correct tag')
-                    elif response_json['api_error_code'] == ERROR_ADD_ON_NOT_ENABLED:
-                        error(
-                            'Missing Add-on. Please enable the add-on via the Snapser Web app.'
-                        )
-                    else:
-                        error(f'Server error: {response_json["message"]}')
-                else:
-                    error(
-                        f'Server error: {json.dumps(response_json, indent=2)}'
+        )
+        progress.start()
+        progress.add_task(description='Creating your snap...', total=None)
+        try:
+            payload = {
+                "service_id": self.sid,
+                "name": self.name,
+                "description": self.desc,
+                "platform": self.platform_type,
+                "language": self.language,
+            }
+            res = requests.post(
+                f"{self.base_url}/v1/snapser-api/byosnaps",
+                json=payload, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            if res.ok:
+                snapctl_success('BYOSNAP create successful', progress)
+            response_json = res.json()
+            if "api_error_code" in response_json and "message" in response_json:
+                if response_json['api_error_code'] == HTTP_ERROR_SERVICE_VERSION_EXISTS:
+                    snapctl_error(
+                        f'BYOSnap {self.name} already exists. Please use a different name',
+                        SNAPCTL_BYOSNAP_CREATE_DUPLICATE_NAME_ERROR,
+                        progress
                     )
-            except RequestException as e:
-                error(f"Exception: Unable to create your snap {e}")
-            return False
+                # elif response_json['api_error_code'] == HTTP_ERROR_TAG_NOT_AVAILABLE:
+                #     error('Invalid tag. Please use the correct tag')
+                if response_json['api_error_code'] == HTTP_ERROR_ADD_ON_NOT_ENABLED:
+                    snapctl_error(
+                        'Missing Add-on. Please enable the add-on via the Snapser Web app.',
+                        SNAPCTL_BYOSNAP_CREATE_PERMISSION_ERROR, progress
+                    )
+            snapctl_error(
+                f'Server error: {json.dumps(response_json, indent=2)}',
+                SNAPCTL_BYOSNAP_CREATE_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(
+                f"Exception: Unable to create your snap {e}",
+                SNAPCTL_BYOSNAP_CREATE_ERROR, progress)
+        snapctl_error('Failed to create snap',
+                      SNAPCTL_BYOSNAP_CREATE_ERROR, progress)
 
-    def publish_image(self) -> bool:
+    def publish_image(self) -> None:
         """
           Publish the image
           1. Check Dependencies
@@ -521,51 +590,64 @@ class ByoSnap:
           5. Push the image
           6. Upload swagger.json
         """
-        if not self._check_dependencies() or not self._docker_login() or \
-            not self._docker_build() or not self._docker_tag() or not self._docker_push() or \
-                not self.upload_docs():
-            return False
-        return True
+        self._check_dependencies()
+        self._docker_login()
+        self._docker_build()
+        self._docker_tag()
+        self._docker_push()
+        self.upload_docs()
+        snapctl_success('BYOSNAP publish successful')
 
-    def publish_version(self) -> bool:
+    def publish_version(self) -> None:
         """
           Publish the version
         """
-        with Progress(
+        progress = Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             transient=True,
-        ) as progress:
-            progress.add_task(
-                description='Publishing your snap...', total=None)
-            try:
-                payload = {
-                    "version": self.version,
-                    "image_tag": self.input_tag,
-                    "base_url": f"{self.prefix}/{self.sid}",
-                    "http_port": self.http_port,
-                }
-                res = requests.post(
-                    f"{self.base_url}/v1/snapser-api/byosnaps/{self.sid}/versions",
-                    json=payload, headers={'api-key': self.api_key},
-                    timeout=SERVER_CALL_TIMEOUT
-                )
-                if res.ok:
-                    return True
-                response_json = res.json()
-                if "api_error_code" in response_json:
-                    if response_json['api_error_code'] == ERROR_SERVICE_VERSION_EXISTS:
-                        error(
-                            'Version already exists. Please update your version and try again'
-                        )
-                    if response_json['api_error_code'] == ERROR_TAG_NOT_AVAILABLE:
-                        error('Invalid tag. Please use the correct tag')
-                else:
-                    error(
-                        f'Server error: {json.dumps(response_json, indent=2)}'
+        )
+        progress.start()
+        progress.add_task(
+            description='Publishing your snap...', total=None)
+        try:
+            profile_data = {}
+            profile_data['dev_template'] = None
+            profile_data['stage_template'] = None
+            profile_data['prod_template'] = None
+            with open(self.byosnap_profile, 'rb') as file:
+                profile_data = json.load(file)
+            payload = {
+                "version": self.version,
+                "image_tag": self.input_tag,
+                "base_url": f"{self.prefix}/{self.sid}",
+                "http_port": self.http_port,
+                "dev_template": profile_data['dev_template'],
+                "stage_template": profile_data['stage_template'],
+                "prod_template": profile_data['prod_template']
+            }
+            res = requests.post(
+                f"{self.base_url}/v1/snapser-api/byosnaps/{self.sid}/versions",
+                json=payload, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            if res.ok:
+                snapctl_success('BYOSNAP publish version successful', progress)
+            response_json = res.json()
+            if "api_error_code" in response_json:
+                if response_json['api_error_code'] == HTTP_ERROR_SERVICE_VERSION_EXISTS:
+                    snapctl_error(
+                        'Version already exists. Please update your version and try again',
+                        SNAPCTL_BYOSNAP_PUBLISH_IMAGE_DUPLICATE_TAG_ERROR,
+                        progress
                     )
-            except RequestException as e:
-                error(
-                    f'Exception: Unable to publish a version for your snap {e}'
-                )
-            return False
+                if response_json['api_error_code'] == HTTP_ERROR_TAG_NOT_AVAILABLE:
+                    snapctl_error('Invalid tag. Please use the correct tag',
+                                  SNAPCTL_BYOSNAP_PUBLISH_VERSION_DUPLICATE_TAG_ERROR, progress)
+            snapctl_error(f'Server error: {json.dumps(response_json, indent=2)}',
+                          SNAPCTL_BYOSNAP_PUBLISH_VERSION_ERROR, progress)
+        except RequestException as e:
+            snapctl_error(f'Exception: Unable to publish a version for your snap {e}',
+                          SNAPCTL_BYOSNAP_PUBLISH_VERSION_ERROR, progress)
+        snapctl_error('Failed to publish version',
+                      SNAPCTL_BYOSNAP_PUBLISH_VERSION_ERROR, progress)