snapctl 0.44.1__py3-none-any.whl → 0.46.0__py3-none-any.whl

snapctl/commands/byosnap.py

@@ -13,6 +13,7 @@ from sys import platform
 from typing import Union, List
 import requests
 from requests.exceptions import RequestException
+import yaml
 
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from snapctl.commands.snapend import Snapend
@@ -27,7 +28,8 @@ from snapctl.config.constants import HTTP_ERROR_SERVICE_VERSION_EXISTS, \
     SNAPCTL_BYOSNAP_PUBLISH_VERSION_ERROR, HTTP_ERROR_SERVICE_IN_USE, \
     SNAPCTL_BYOSNAP_UPDATE_VERSION_ERROR, SNAPCTL_BYOSNAP_UPDATE_VERSION_SERVICE_IN_USE_ERROR, \
     SNAPCTL_BYOSNAP_UPDATE_VERSION_TAG_ERROR, SNAPCTL_BYOSNAP_NOT_FOUND, \
-    HTTP_ERROR_RESOURCE_NOT_FOUND, SNAPCTL_BYOSNAP_PUBLISH_ERROR
+    HTTP_ERROR_RESOURCE_NOT_FOUND, SNAPCTL_BYOSNAP_PUBLISH_ERROR, \
+    SNAPCTL_BYOSNAP_GENERATE_PROFILE_ERROR
 from snapctl.utils.echo import info, warning, success
 from snapctl.utils.helper import get_composite_token, snapctl_error, snapctl_success, \
     check_dockerfile_architecture
@@ -38,11 +40,21 @@ class ByoSnap:
       CLI commands exposed for a BYOSnap
     """
     ID_PREFIX = 'byosnap-'
+    # These are active today
     SUBCOMMANDS = [
-        'create', 'publish-image', 'publish-version', 'upload-docs', 'update-version',
-        'publish', 'sync'
+        'publish', 'sync', 'upload-docs', 'generate-profile', 'validate-profile',
+        'create', 'publish-image', 'publish-version', 'update-version',
     ]
-    PROFILE_NAME = 'snapser-byosnap-profile.json'
+    # These are the real commands that we want to show in the help text
+    SHOW_SUBCOMMANDS = ['publish', 'sync', 'upload-docs',
+                        'generate-profile', 'validate-profile']
+    # These are the commands that we want to deprecate
+    TO_DEPRECATE_SUBCOMMANDS = [
+        'create', 'publish-image', 'publish-version', 'update-version']
+    DEFAULT_PROFILE_NAME_JSON = 'snapser-byosnap-profile.json'
+    DEFAULT_PROFILE_NAME_YAML = 'snapser-byosnap-profile.yaml'
+    PROFILE_FILES_PATH = 'snapctl/data/profiles/'
+    PROFILE_FORMATS = ['json', 'yaml', 'yml']
     PLATFORMS = ['linux/arm64', 'linux/amd64']
     LANGUAGES = ['go', 'node', 'python', 'java', 'csharp', 'cpp', 'rust',
                  'ruby', 'php', 'perl', 'clojure', 'lua', 'ts', 'js', 'kotlin', 'c']
@@ -55,32 +67,26 @@ class ByoSnap:
     MAX_MIN_REPLICAS = 4
 
     def __init__(
-        self, *, subcommand: str, base_url: str, api_key: Union[str, None], sid: str,
+        self, *, subcommand: str, base_url: str, api_key: Union[str, None], byosnap_id: str,
         name: Union[str, None] = None, desc: Union[str, None] = None,
         platform_type: Union[str, None] = None, language: Union[str, None] = None,
         tag: Union[str, None] = None, path: Union[str, None] = None,
-        resources_path: Union[str, None] = None,  docker_file: Union[str, None] = None,
+        resources_path: Union[str, None] = None,  docker_filename: Union[str, None] = None,
         version: Union[str, None] = None, skip_build: bool = False,
         snapend_id: Union[str, None] = None, blocking: bool = False,
-        byosnap_profile_file: Union[str, None] = None
+        profile_filename: Union[str, None] = None,
+        out_path: Union[str, None] = None
     ) -> None:
         # Set the BASE variables
         self.subcommand: str = subcommand
         self.base_url: str = base_url
         self.api_key: Union[str, None] = api_key
-        self.sid: str = sid
-        self.token: Union[str, None] = None
-        self.token_parts: Union[list, None] = None
-        self.byosnap_profile: Union[str, None] = None
-        if subcommand not in ['create', 'publish']:
-            # Create does not need the token
-            # Publish handles this in the publish-image subcommand
-            self._setup_token_and_token_parts(base_url, api_key, sid)
+        self.byosnap_id: str = byosnap_id
         self.tag: Union[str, None] = tag
         self.path: Union[str, None] = path
         self.resources_path: Union[str, None] = resources_path
-        self.docker_file: str = docker_file
-        self.byosnap_profile_file: Union[str, None] = byosnap_profile_file
+        self.docker_filename: str = docker_filename
+        self.profile_filename: Union[str, None] = profile_filename
         self.version: Union[str, None] = version
         self.name: Union[str, None] = name
         self.desc: Union[str, None] = desc
@@ -89,16 +95,21 @@ class ByoSnap:
         self.snapend_id: Union[str, None] = snapend_id
         self.skip_build: bool = skip_build
         self.blocking: bool = blocking
-        # Override
+        self.out_path: Union[str, None] = out_path
+        # Values below will be overridden
+        self.token: Union[str, None] = None
+        self.token_parts: Union[list, None] = None
+        self.profile_path: Union[str, None] = None
+        self.profile_data: Union[dict, None] = None
+        # These variables are here because of backward compatibility
+        # We now takes these inputs from the BYOSnap profile
         self.prefix: Union[str, None] = None
         self.ingress_external_port: Union[dict, None] = None
         self.ingress_internal_ports: Union[list, None] = None
         self.readiness_path: Union[str, None] = None
         self.readiness_delay: Union[str, None] = None
-        if self.subcommand in ['publish', 'publish-version']:
-            self._validate_and_override_properties_from_profile()
-        # Validate the input
-        self.validate_input()
+        # Setup and Validate the input
+        self.setup_and_validate_input()
 
     # Protected methods
     @staticmethod
@@ -123,32 +134,227 @@ class ByoSnap:
             pass
         return None
 
-    def _setup_token_and_token_parts(self, base_url, api_key, sid) -> None:
-        '''
-        Setup the token and token parts for publishing and syncing
-        '''
-        self.token: Union[str, None] = get_composite_token(
-            base_url, api_key,
-            'byosnap', {'service_id': sid}
-        )
-        self.token_parts: Union[list, None] = ByoSnap._get_token_values(
-            self.token) if self.token is not None else None
-
-    def _check_and_get_byosnap_profile(self) -> object:
-        """
-          Validate the BYOSnap profile
-        """
-        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:
+    @staticmethod
+    def _validate_byosnap_profile_data(profile_data) -> None:
+        # Check for the parent fields
+        for field in ['name', 'description', 'platform', 'language', 'prefix',
+                      'readiness_probe_config', 'dev_template', 'stage_template', 'prod_template']:
+            if field not in profile_data:
+                snapctl_error(
+                    message=f'BYOSnap profile requires {field} field. ' +
+                    'Please use the following command: ' +
+                    '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                    'to generate a new profile',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+        # Check for backward compatible fields
+        if 'http_port' not in profile_data and 'ingress' not in profile_data:
             snapctl_error(
-                message='Invalid BYOSnap profile JSON. Please check the JSON structure',
+                message='BYOSnap profile requires an ingress field with external_port and ' +
+                'internal_port as children. Note: http_port is going to be deprecated soon. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # Name Check
+        if profile_data['name'] is None or profile_data['name'].strip() == '':
+            snapctl_error(
+                message='BYOSnap profile requires a non empty name value. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # Description Check
+        if profile_data['description'] is None or profile_data['description'].strip() == '':
+            snapctl_error(
+                message='BYOSnap profile requires a non empty description value. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # Platform Check
+        if profile_data['platform'] is None or \
+                profile_data['platform'].strip() not in ByoSnap.PLATFORMS:
+            snapctl_error(
+                message='Invalid platform value in BYOSnap profile. Valid values are ' +
+                f'{", ".join(map(str, ByoSnap.PLATFORMS))}.',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # Language Check
+        if profile_data['language'] is None or profile_data['language'].strip() == '':
+            snapctl_error(
+                message='BYOSnap profile requires a non empty language value. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # Prefix Checks
+        if profile_data['prefix'] is None or profile_data['prefix'].strip() == '':
+            snapctl_error(
+                message='BYOSnap profile requires a non empty prefix value. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        if not profile_data['prefix'].strip().startswith('/') or \
+                profile_data['prefix'].strip().endswith('/') or \
+                profile_data['prefix'].strip().count('/') > 1:
+            snapctl_error(
+                message='Invalid prefix value in BYOSnap profile. ' +
+                'Prefix should start with a forward slash (/) and should contain exactly one ' +
+                'path segment.',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # HTTP Port and Ingress Checks
+        if 'http_port' in profile_data:
+            if profile_data['http_port'] is None or \
+                    not isinstance(profile_data['http_port'], int):
+                snapctl_error(
+                    message='Invalid http_port value in BYOSnap profile. ' +
+                    'HTTP port should be a number.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            warning('http_port is deprecated. Please use ingress.external_port. ' +
+                    'You can generate a new BYOSnap profile via the `generate` command.')
+        # Ingress Checks
+        if 'ingress' in profile_data:
+            if profile_data['ingress'] is None:
+                snapctl_error(
+                    message='BYOSnap profile requires an ingress field with external_port and ' +
+                    'internal_port as children. Please use the following command: ' +
+                    '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                    'to generate a new profile',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if 'external_port' not in profile_data['ingress']:
+                snapctl_error(
+                    message='BYOSnap profile requires an ingress.external_port field. ' +
+                    'Please use the following command: ' +
+                    '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                    'to generate a new profile',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if 'name' not in profile_data['ingress']['external_port'] or \
+                    profile_data['ingress']['external_port']['name'] != 'http':
+                snapctl_error(
+                    message='Invalid Ingress external_port value in BYOSnap profile. ' +
+                    'External port should have a name of http and a number port value.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if 'port' not in profile_data['ingress']['external_port'] or \
+                profile_data['ingress']['external_port']['port'] is None or \
+                    not isinstance(profile_data['ingress']['external_port']['port'], int):
+                snapctl_error(
+                    message='Invalid Ingress external_port value in BYOSnap profile. ' +
+                    'External port should have a name of http and a number port value.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if 'internal_ports' not in profile_data['ingress'] or \
+                    not isinstance(profile_data['ingress']['internal_ports'], list):
+                snapctl_error(
+                    message='Invalid Ingress internal_port value in BYOSnap profile. ' +
+                    'Internal port should be an empty list or a list of objects with name and ' +
+                    'port values.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            duplicate_name = {}
+            duplicate_port = {}
+            index = 0
+            for internal_port_obj in profile_data['ingress']['internal_ports']:
+                index += 1
+                if 'name' not in internal_port_obj or 'port' not in internal_port_obj:
+                    snapctl_error(
+                        message='Invalid Ingress internal_port value in BYOSnap profile. ' +
+                        'Internal port should be an object with name and port values. ' +
+                        f"Check the internal port number #{index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+                if internal_port_obj['name'] is None or internal_port_obj['name'].strip() == '':
+                    snapctl_error(
+                        message='Invalid Ingress internal_port value in BYOSnap profile. ' +
+                        'Internal port name should not be empty. ' +
+                        f"Check the internal port number #{index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+                if internal_port_obj['port'] is None or \
+                        not isinstance(internal_port_obj['port'], int):
+                    snapctl_error(
+                        message='Invalid Ingress internal_port value in BYOSnap profile. ' +
+                        'Internal port port should be a number. ' +
+                        f"Check the internal port number #{index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+                # Confirm the name does not collide with the external port
+                if internal_port_obj['name'] == profile_data['ingress']['external_port']['name']:
+                    snapctl_error("Internal port name should not be the same as " +
+                                  "the external port name. " +
+                                  f"Check the internal port number #{index}.",
+                                  SNAPCTL_INPUT_ERROR)
+                if internal_port_obj['port'] == profile_data['ingress']['external_port']['port']:
+                    snapctl_error("Internal port number should not be the same as " +
+                                  "the external port number. " +
+                                  f"Check the internal port number #{index}.",
+                                  SNAPCTL_INPUT_ERROR)
+                if internal_port_obj['name'] in duplicate_name:
+                    snapctl_error("Duplicate internal port name. " +
+                                  f"Check the internal port number #{index}.",
+                                  SNAPCTL_INPUT_ERROR)
+                if internal_port_obj['port'] in duplicate_port:
+                    snapctl_error("Duplicate internal port number. " +
+                                  f"Check the internal port number #{index}.",
+                                  SNAPCTL_INPUT_ERROR)
+                duplicate_name[internal_port_obj['name']] = True
+                duplicate_port[internal_port_obj['port']] = True
+        # Readiness Probe Checks
+        if 'readiness_probe_config' not in profile_data:
+            snapctl_error(
+                message='BYOSnap profile requires a readiness_probe_config field. ' +
+                'Please use the following command: ' +
+                '`snapctl byosnap generate-profile --out-path $output_path` ' +
+                'to generate a new profile',
                 code=SNAPCTL_INPUT_ERROR
             )
+        if 'initial_delay_seconds' not in profile_data['readiness_probe_config'] or \
+                'path' not in profile_data['readiness_probe_config']:
+            snapctl_error(
+                message='Invalid readiness_probe_config value in BYOSnap profile. ' +
+                'Readiness probe config should have an initial_delay_seconds and path value. ' +
+                'Set both to null if not required.',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        if (profile_data['readiness_probe_config']['initial_delay_seconds'] is None and
+            profile_data['readiness_probe_config']['path'] is not None) or \
+                (profile_data['readiness_probe_config']['initial_delay_seconds'] is not None and
+                 profile_data['readiness_probe_config']['path'] is None):
+            snapctl_error(
+                message='Invalid readiness_probe_config value in BYOSnap profile. ' +
+                'Readiness probe config should have both initial_delay_seconds and path values. ' +
+                'One of them cannot be null. However, set both to null if not required.',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        if profile_data['readiness_probe_config']['path'] is not None is not None:
+            if profile_data['readiness_probe_config']['path'].strip() == '':
+                snapctl_error(
+                    "Invalid readiness_probe_config.path value. Readiness path cannot be empty",
+                    SNAPCTL_INPUT_ERROR)
+            if not profile_data['readiness_probe_config']['path'].strip().startswith('/'):
+                snapctl_error(
+                    "Invalid readiness_probe_config.path value. Readiness path has to start with /",
+                    SNAPCTL_INPUT_ERROR)
+        if profile_data['readiness_probe_config']['initial_delay_seconds'] is not None:
+            if not isinstance(profile_data['readiness_probe_config']['initial_delay_seconds'], int) or \
+               profile_data['readiness_probe_config']['initial_delay_seconds'] < 0 or \
+               profile_data['readiness_probe_config']['initial_delay_seconds'] > ByoSnap.MAX_READINESS_TIMEOUT:
+                snapctl_error(
+                    "Invalid readiness_probe_config.path value. " +
+                    "Readiness delay should be between 0 " +
+                    f"and {ByoSnap.MAX_READINESS_TIMEOUT}", SNAPCTL_INPUT_ERROR)
+        # Template Object Checks
         if 'dev_template' not in profile_data or \
             'stage_template' not in profile_data or \
                 'prod_template' not in profile_data:
@@ -157,175 +363,224 @@ class ByoSnap:
                 code=SNAPCTL_INPUT_ERROR
             )
         for profile in ['dev_template', 'stage_template', 'prod_template']:
-            # Currently, not checking for 'min_replicas' not in profile_data[profile]
-            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(
-                    message='Invalid BYOSnap profile JSON. Please check the JSON structure',
-                    code=SNAPCTL_INPUT_ERROR
-                )
-            if profile_data[profile]['cpu'] not in ByoSnap.VALID_CPU_MARKS:
+            # IMPORTANT: Not checking for in min_replicas for backward compatibility
+            for field in ['cpu', 'memory', 'cmd', 'args', 'env_params']:
+                if field not in profile_data[profile]:
+                    snapctl_error(
+                        message='Invalid BYOSnap profile JSON. ' +
+                        f'{profile} requires cpu, memory, min_replicas, cmd, args, and ' +
+                        'env_params fields.',
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+            if profile_data[profile]['cpu'] is None or \
+                    profile_data[profile]['cpu'] not in ByoSnap.VALID_CPU_MARKS:
                 snapctl_error(
                     message='Invalid CPU value in BYOSnap profile. Valid values are' +
-                    f'{", ".join(map(str, ByoSnap.VALID_CPU_MARKS))}',
+                    f'{", ".join(map(str, ByoSnap.VALID_CPU_MARKS))}.',
                     code=SNAPCTL_INPUT_ERROR
                 )
-            if profile_data[profile]['memory'] not in ByoSnap.VALID_MEMORY_MARKS:
+            if profile_data[profile]['memory'] is None or \
+                    profile_data[profile]['memory'] not in ByoSnap.VALID_MEMORY_MARKS:
                 snapctl_error(
                     message='Invalid Memory value in BYOSnap profile. Valid values are ' +
-                    f'{", ".join(map(str, ByoSnap.VALID_MEMORY_MARKS))}',
+                    f'{", ".join(map(str, ByoSnap.VALID_MEMORY_MARKS))}.',
                     code=SNAPCTL_INPUT_ERROR
                 )
             if 'min_replicas' in profile_data[profile] and \
+                profile_data[profile]['min_replicas'] is not None and \
                 (not isinstance(profile_data[profile]['min_replicas'], int) or
-                    int(profile_data[profile]['min_replicas']) < 0 or
-                 int(profile_data[profile]['min_replicas']) > ByoSnap.MAX_MIN_REPLICAS):
+                    profile_data[profile]['min_replicas'] < 0 or
+                 profile_data[profile]['min_replicas'] > ByoSnap.MAX_MIN_REPLICAS):
                 snapctl_error(
                     message='Invalid Min Replicas value in BYOSnap profile. ' +
                     'Minimum replicas should be between 0 and ' +
                     f'{ByoSnap.MAX_MIN_REPLICAS}',
                     code=SNAPCTL_INPUT_ERROR
                 )
-        if 'name' not in profile_data or 'description' not in profile_data or \
-            'platform' not in profile_data or 'language' not in profile_data or \
-                'prefix' not in profile_data or \
-            ('http_port' not in profile_data and 'ingress' not in profile_data) or \
-                'readiness_probe_config' not in profile_data or \
-                'initial_delay_seconds' not in profile_data['readiness_probe_config'] or \
-                'path' not in profile_data['readiness_probe_config']:
+            if 'min_replicas' in profile_data[profile] and \
+                profile_data[profile]['min_replicas'] is not None and \
+                isinstance(profile_data[profile]['min_replicas'], int) and \
+                profile_data[profile]['min_replicas'] > 1 and \
+                    (profile == 'dev_template' or profile == 'stage_template'):
+                snapctl_error(
+                    message='Invalid Min Replicas value in BYOSnap profile. ' +
+                    'Minimum replicas should be 1 for dev and stage templates.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+
+            if profile_data[profile]['cmd'] is None:
+                snapctl_error(
+                    message='Invalid CMD value in BYOSnap profile. CMD should not be an ' +
+                    'empty string or the command you want to run in the container.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if profile_data[profile]['args'] is None or \
+                    not isinstance(profile_data[profile]['args'], list):
+                snapctl_error(
+                    message='Invalid ARGS value in BYOSnap profile. ARGS should be a ' +
+                    'list of arguments or an empty list if no arguments are required.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if profile_data[profile]['env_params'] is None or \
+                    not isinstance(profile_data[profile]['env_params'], list):
+                snapctl_error(
+                    message='Invalid env_params value in BYOSnap profile. env_params should be a ' +
+                    'list of environment variables as a dict with key and value attribute. ' +
+                    'It can be  an empty list if no environment variables are required.',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            env_index = 0
+            for env_param in profile_data[profile]['env_params']:
+                env_index += 1
+                if 'key' not in env_param or 'value' not in env_param:
+                    snapctl_error(
+                        message='Invalid env_params value in BYOSnap profile. env_params should ' +
+                        'be a list of environment variables as a dict with key and value ' +
+                        'attribute. It can be an empty list if no environment variables ' +
+                        'are required. ' +
+                        f"Check the entry {profile}.env_params #{env_index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+                if env_param['key'] is None or env_param['key'].strip() == '':
+                    snapctl_error(
+                        message='Invalid env_params value in BYOSnap profile. env_params key ' +
+                        'should not be empty. ' +
+                        f"Check the key entry at {
+                            profile}.env_params #{env_index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+                if env_param['value'] is None or env_param['value'].strip() == '':
+                    snapctl_error(
+                        message='Invalid env_params value in BYOSnap profile. env_params value ' +
+                        'should not be empty. ' +
+                        f"Check the value entry at {
+                            profile}.env_params #{env_index}.",
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+        return profile_data
+
+    @staticmethod
+    def _validate_byosnap_id(byosnap_id: str) -> None:
+        if not byosnap_id.startswith(ByoSnap.ID_PREFIX):
             snapctl_error(
-                message='BYOSnap profile now requires name, description, platform, ' +
-                'language, prefix, ingress, and readiness_probe_config fields. ' +
-                'Please use the following command: ' +
-                '`snapctl generate profile --category byosnap --out-path $output_path` ' +
-                'to generate a new profile',
+                message="Invalid Snap ID. Valid Snap IDs start with " +
+                f"{ByoSnap.ID_PREFIX}.",
                 code=SNAPCTL_INPUT_ERROR
             )
-        return profile_data
+        if len(byosnap_id) > ByoSnap.SID_CHARACTER_LIMIT:
+            snapctl_error(
+                message="Invalid Snap ID. Snap ID should be less than " +
+                f"{ByoSnap.SID_CHARACTER_LIMIT} characters",
+                code=SNAPCTL_INPUT_ERROR
+            )
+
+    @staticmethod
+    def _handle_output_file(input_filepath, output_filepath) -> bool:
+        file_written = False
+        with open(input_filepath, 'r') as in_file, open(output_filepath, 'w') as outfile:
+            for line in in_file:
+                outfile.write(line)
+            file_written = True
+        return file_written
 
-    def _validate_and_override_properties_from_profile(self) -> None:
-        # Build your snap
-        if self.resources_path:
-            base_path = self.resources_path
+    def _get_profile_contents(self) -> dict:
+        """
+          Get the BYOSNap profile contents
+          based on if the user has a YAML or JSON file
+        """
+        profile_contents = {}
+        with open(self.profile_path, 'rb') as file:
+            try:
+                if self.profile_filename.endswith('.yaml') or\
+                        self.profile_filename.endswith('.yml'):
+                    yaml_content = yaml.safe_load(file)
+                    file_contents = json.dumps(yaml_content)
+                    profile_contents = json.loads(file_contents)
+                else:
+                    profile_contents = json.load(file)
+            except json.JSONDecodeError:
+                pass
+        return profile_contents
+
+    def _setup_token_and_token_parts(self, base_url, api_key, byosnap_id) -> None:
+        '''
+        Setup the token and token parts for publishing and syncing
+        '''
+        self.token: Union[str, None] = get_composite_token(
+            base_url, api_key,
+            'byosnap', {'service_id': byosnap_id}
+        )
+        self.token_parts: Union[list, None] = ByoSnap._get_token_values(
+            self.token) if self.token is not None else None
+
+    def _setup_and_validate_byosnap_profile_data(self) -> None:
+        """
+          Pre-Override Validator
+        """
+        # Check dependencies
+        if self.path is None and self.resources_path is None:
+            snapctl_error(
+                message='Either the path or resources path is required ' +
+                'to import the BYOSnap profile.',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        base_path = self.resources_path if self.resources_path else self.path
+        # Publish and Publish version
+        if not self.profile_filename:
+            self.profile_filename = ByoSnap.DEFAULT_PROFILE_NAME_JSON
         else:
-            base_path = self.path
-        if not self.byosnap_profile_file:
-            self.byosnap_profile_file = ByoSnap.PROFILE_NAME
-        self.byosnap_profile = os.path.join(
-            base_path, self.byosnap_profile_file)
-        if not os.path.isfile(self.byosnap_profile):
+            if not self.profile_filename.endswith('.json') and \
+                not self.profile_filename.endswith('.yaml') and \
+                    not self.profile_filename.endswith('.yml'):
+                snapctl_error(
+                    message='Invalid BYOSnap profile file. Please check the file extension' +
+                    ' and ensure it is either .json, .yaml, or .yml',
+                    code=SNAPCTL_INPUT_ERROR
+                )
+        self.profile_path = os.path.join(
+            base_path, self.profile_filename)
+        if not os.path.isfile(self.profile_path):
             snapctl_error(
                 "Unable to find " +
-                f"{self.byosnap_profile_file} at path {base_path}",
+                f"{self.profile_filename} at path {base_path}",
                 SNAPCTL_INPUT_ERROR)
-        info('Extracting information from BYOSnap profile at path ' +
-             f'{self.byosnap_profile}')
-        profile_data = self._check_and_get_byosnap_profile()
-        self.name = profile_data['name']
-        self.desc = profile_data['description']
-        self.platform_type = profile_data['platform']
-        self.language = profile_data['language']
-        self.prefix = profile_data['prefix']
+        profile_data_obj = self._get_profile_contents()
+        if not profile_data_obj:
+            snapctl_error(
+                message='Invalid BYOSnap profile JSON. Please check the JSON structure',
+                code=SNAPCTL_INPUT_ERROR
+            )
+        # IMPORTANT: This is where the profile data is set and validated
+        self.profile_data = profile_data_obj
+        ByoSnap._validate_byosnap_profile_data(self.profile_data)
+        # End: IMPORTANT: This is where the profile data is set
+        # Now apply the overrides
+        self.name = self.profile_data['name']
+        self.desc = self.profile_data['description']
+        self.platform_type = self.profile_data['platform']
+        self.language = self.profile_data['language']
+        self.prefix = self.profile_data['prefix']
         # Setup the final ingress external port
         final_ingress_external_port = {
             'name': 'http',
             'port': None
         }
-        if 'http_port' in profile_data:
+        if 'http_port' in self.profile_data:
             final_ingress_external_port = {
                 'name': 'http',
-                'port': profile_data['http_port']
+                'port': self.profile_data['http_port']
             }
-            warning('http_port is deprecated. Please use ingress.external_port. ' +
-                    'You can generate a new BYOSnap profile via the `generate` command.')
-        elif 'ingress' in profile_data and 'external_port' in profile_data['ingress']:
-            final_ingress_external_port = profile_data['ingress']['external_port']
+        elif 'ingress' in self.profile_data and 'external_port' in self.profile_data['ingress']:
+            final_ingress_external_port = self.profile_data['ingress']['external_port']
         self.ingress_external_port = final_ingress_external_port
         # Setup the final ingress internal ports
         final_ingress_internal_ports = []
-        if 'ingress' in profile_data and 'internal_ports' in profile_data['ingress']:
-            final_ingress_internal_ports = profile_data['ingress']['internal_ports']
+        if 'ingress' in self.profile_data and 'internal_ports' in self.profile_data['ingress']:
+            final_ingress_internal_ports = self.profile_data['ingress']['internal_ports']
         self.ingress_internal_ports = final_ingress_internal_ports
-        self.readiness_path = profile_data['readiness_probe_config']['path']
+        self.readiness_path = self.profile_data['readiness_probe_config']['path']
         self.readiness_delay = \
-            profile_data['readiness_probe_config']['initial_delay_seconds']
-        # Validate
-        if not self.prefix or self.prefix == '':
-            snapctl_error("Missing prefix", SNAPCTL_INPUT_ERROR)
-        if not self.prefix.startswith('/'):
-            snapctl_error("Prefix should start with a forward slash (/)",
-                          SNAPCTL_INPUT_ERROR)
-        if self.prefix.endswith('/'):
-            snapctl_error("Prefix should not end with a forward slash (/)",
-                          SNAPCTL_INPUT_ERROR)
-        # check that prefix does not contain multiple slashes
-        if self.prefix.count('/') > 1:
-            snapctl_error("Prefix should not contain multiple path segments",
-                          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):
-            snapctl_error("Version should be in the format vX.X.X",
-                          SNAPCTL_INPUT_ERROR)
-        if not self.ingress_external_port['port']:
-            snapctl_error("Missing Ingress HTTP Port",
-                          SNAPCTL_INPUT_ERROR)
-        if not isinstance(self.ingress_external_port['port'], int):
-            snapctl_error("Ingress external port should be a number",
-                          SNAPCTL_INPUT_ERROR)
-        # Check internal ports
-        duplicate_name = {}
-        duplicate_port = {}
-        index = 0
-        for internal_port in self.ingress_internal_ports:
-            if 'name' not in internal_port or 'port' not in internal_port:
-                snapctl_error("Internal ports need a name and a port. Check internal port " +
-                              f"number {index}.",
-                              SNAPCTL_INPUT_ERROR)
-            # Confirm the name does not collide with the external port
-            if internal_port['name'] == self.ingress_external_port['name']:
-                snapctl_error("Internal port name should not be the same as " +
-                              "the external port name", SNAPCTL_INPUT_ERROR)
-            # Confirm the port does not collide with the external port
-            if internal_port['port'] == self.ingress_external_port['port']:
-                snapctl_error("Internal port number should not be the same as " +
-                              "the external port number", SNAPCTL_INPUT_ERROR)
-            index += 1
-            if not internal_port['port']:
-                snapctl_error("Missing internal port. Check internal port " +
-                              f"number {index}",
-                              SNAPCTL_INPUT_ERROR)
-            if not isinstance(internal_port['port'], int):
-                snapctl_error("Internal port should be a number. Check internal port " +
-                              f"number {index}",
-                              SNAPCTL_INPUT_ERROR)
-            if internal_port['name'] in duplicate_name:
-                snapctl_error("Duplicate internal port name. Check internal port " +
-                              f"number {index}",
-                              SNAPCTL_INPUT_ERROR)
-            if internal_port['port'] in duplicate_port:
-                snapctl_error("Duplicate internal port number. Check internal port " +
-                              f"number {index}",
-                              SNAPCTL_INPUT_ERROR)
-            duplicate_name[internal_port['name']] = True
-            duplicate_port[internal_port['port']] = True
-        if self.readiness_path is not None:
-            if self.readiness_path.strip() == '':
-                snapctl_error("Readiness path cannot be empty",
-                              SNAPCTL_INPUT_ERROR)
-            if not self.readiness_path.strip().startswith('/'):
-                snapctl_error("Readiness path has to start with /",
-                              SNAPCTL_INPUT_ERROR)
-        if self.readiness_delay is not None:
-            if self.readiness_delay < 0 or \
-                    self.readiness_delay > ByoSnap.MAX_READINESS_TIMEOUT:
-                snapctl_error(
-                    "Readiness delay should be between 0 " +
-                    f"and {ByoSnap.MAX_READINESS_TIMEOUT}", SNAPCTL_INPUT_ERROR)
+            self.profile_data['readiness_probe_config']['initial_delay_seconds']
 
     def _check_dependencies(self) -> None:
         """
@@ -420,7 +675,7 @@ class ByoSnap:
 
     def _docker_build(self) -> None:
         # Get the data
-        # image_tag = f'{self.sid}.{self.tag}'
+        # image_tag = f'{self.byosnap_id}.{self.tag}'
         build_platform = ByoSnap.DEFAULT_BUILD_PLATFORM
         if len(self.token_parts) == 4:
             build_platform = self.token_parts[3]
@@ -438,7 +693,7 @@ class ByoSnap:
                 base_path = self.resources_path
             else:
                 base_path = self.path
-            docker_file_path = os.path.join(base_path, self.docker_file)
+            docker_file_path = os.path.join(base_path, self.docker_filename)
 
             # Warning check for architecture specific commands
             info(f'Building on system architecture {sys_platform.machine()}')
@@ -478,7 +733,7 @@ class ByoSnap:
     def _docker_tag(self) -> None:
         # Get the data
         ecr_repo_url = self.token_parts[0]
-        image_tag = f'{self.sid}.{self.tag}'
+        image_tag = f'{self.byosnap_id}.{self.tag}'
         full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
         progress = Progress(
             SpinnerColumn(),
@@ -525,7 +780,7 @@ class ByoSnap:
         try:
             # Push the image
             ecr_repo_url = self.token_parts[0]
-            image_tag = f'{self.sid}.{self.tag}'
+            image_tag = f'{self.byosnap_id}.{self.tag}'
             full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
             if platform == "win32":
                 response = subprocess.run([
@@ -580,8 +835,8 @@ class ByoSnap:
 
     # Public methods
 
-    # Validator
-    def validate_input(self) -> None:
+    # Validate
+    def setup_and_validate_input(self) -> None:
         """
           Validator
         """
@@ -596,21 +851,10 @@ class ByoSnap:
                 f"{', '.join(ByoSnap.SUBCOMMANDS)}.",
                 code=SNAPCTL_INPUT_ERROR
             )
-        # Validate the SID
-        if not self.sid.startswith(ByoSnap.ID_PREFIX):
-            snapctl_error(
-                message="Invalid Snap ID. Valid Snap IDs start with " +
-                f"{ByoSnap.ID_PREFIX}.",
-                code=SNAPCTL_INPUT_ERROR
-            )
-        if len(self.sid) > ByoSnap.SID_CHARACTER_LIMIT:
-            snapctl_error(
-                message="Invalid Snap ID. Snap ID should be less than " +
-                f"{ByoSnap.SID_CHARACTER_LIMIT} characters",
-                code=SNAPCTL_INPUT_ERROR
-            )
         # Validation for subcommands
         if self.subcommand == 'create':
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if self.name == '':
                 snapctl_error(message="Missing name", code=SNAPCTL_INPUT_ERROR)
             if not self.language:
@@ -629,9 +873,14 @@ class ByoSnap:
                     code=SNAPCTL_INPUT_ERROR
                 )
         elif self.subcommand == 'publish-image':
+            # Setup
+            self._setup_token_and_token_parts(
+                self.base_url, self.api_key, self.byosnap_id)
+            # Validator
             if self.token_parts is None:
                 snapctl_error('Invalid token. Please reach out to your support team.',
                               SNAPCTL_INPUT_ERROR)
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if not self.tag:
                 snapctl_error(
                     "Missing required parameter: tag", SNAPCTL_INPUT_ERROR)
@@ -648,15 +897,20 @@ class ByoSnap:
             # Check path
             if self.resources_path:
                 docker_file_path = \
-                    f"{self.resources_path}/{self.docker_file}"
+                    f"{self.resources_path}/{self.docker_filename}"
             else:
-                docker_file_path = f"{self.path}/{self.docker_file}"
+                docker_file_path = f"{self.path}/{self.docker_filename}"
             if not self.skip_build and not os.path.isfile(docker_file_path):
                 snapctl_error(
                     "Unable to find " +
-                    f"{self.docker_file} at path {docker_file_path}",
+                    f"{self.docker_filename} at path {docker_file_path}",
                     SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'upload-docs':
+            # Setup
+            self._setup_token_and_token_parts(
+                self.base_url, self.api_key, self.byosnap_id)
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if self.token_parts is None:
                 snapctl_error('Invalid token. Please reach out to your support team.',
                               SNAPCTL_INPUT_ERROR)
@@ -673,6 +927,13 @@ class ByoSnap:
                     SNAPCTL_INPUT_ERROR
                 )
         elif self.subcommand == 'publish-version':
+            # Setup
+            self._setup_token_and_token_parts(
+                self.base_url, self.api_key, self.byosnap_id)
+            # Setup the profile data
+            self._setup_and_validate_byosnap_profile_data()
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if self.token_parts is None:
                 snapctl_error('Invalid token. Please reach out to your support team.',
                               SNAPCTL_INPUT_ERROR)
@@ -686,7 +947,18 @@ class ByoSnap:
                     f"{ByoSnap.TAG_CHARACTER_LIMIT} characters",
                     SNAPCTL_INPUT_ERROR
                 )
+            if not self.version:
+                snapctl_error("Missing version", SNAPCTL_INPUT_ERROR)
+                pattern = r'^v\d+\.\d+\.\d+$'
+            if not re.match(r'^v\d+\.\d+\.\d+$', self.version):
+                snapctl_error("Version should be in the format vX.X.X",
+                              SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'update-version':
+            # Setup
+            self._setup_token_and_token_parts(
+                self.base_url, self.api_key, self.byosnap_id)
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if self.token_parts is None:
                 snapctl_error('Invalid token. Please reach out to your support team.',
                               SNAPCTL_INPUT_ERROR)
@@ -709,6 +981,11 @@ class ByoSnap:
                     code=SNAPCTL_INPUT_ERROR
                 )
         elif self.subcommand == 'sync':
+            # Setup
+            self._setup_token_and_token_parts(
+                self.base_url, self.api_key, self.byosnap_id)
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if self.token_parts is None:
                 snapctl_error('Invalid token. Please reach out to your support team.',
                               SNAPCTL_INPUT_ERROR)
@@ -726,20 +1003,27 @@ class ByoSnap:
             # Check path
             if self.resources_path:
                 docker_file_path = \
-                    f"{self.resources_path}/{self.docker_file}"
+                    f"{self.resources_path}/{self.docker_filename}"
             else:
-                docker_file_path = f"{self.path}/{self.docker_file}"
+                docker_file_path = f"{self.path}/{self.docker_filename}"
             if not self.skip_build and not os.path.isfile(docker_file_path):
                 snapctl_error(
                     message="Unable to find " +
-                    f"{self.docker_file} at path {docker_file_path}",
+                    f"{self.docker_filename} at path {docker_file_path}",
+                    code=SNAPCTL_INPUT_ERROR)
+            if not self.snapend_id:
+                snapctl_error(
+                    message="Missing required parameter: snapend-id",
                     code=SNAPCTL_INPUT_ERROR)
         elif self.subcommand == 'publish':
+            # Setup the profile data
+            self._setup_and_validate_byosnap_profile_data()
+            # Validator
+            ByoSnap._validate_byosnap_id(self.byosnap_id)
             if not self.version:
                 snapctl_error(message="Missing version. Version should be in the format vX.X.X",
                               code=SNAPCTL_INPUT_ERROR)
-            pattern = r'^v\d+\.\d+\.\d+$'
-            if not re.match(pattern, self.version):
+            if not re.match(r'^v\d+\.\d+\.\d+$', self.version):
                 snapctl_error(message="Version should be in the format vX.X.X",
                               code=SNAPCTL_INPUT_ERROR)
             if not self.skip_build and not self.path:
@@ -749,14 +1033,46 @@ class ByoSnap:
             # Check path
             if self.resources_path:
                 docker_file_path = \
-                    f"{self.resources_path}/{self.docker_file}"
+                    f"{self.resources_path}/{self.docker_filename}"
             else:
-                docker_file_path = f"{self.path}/{self.docker_file}"
+                docker_file_path = f"{self.path}/{self.docker_filename}"
             if not self.skip_build and not os.path.isfile(docker_file_path):
                 snapctl_error(
                     message="Unable to find " +
-                    f"{self.docker_file} at path {docker_file_path}",
+                    f"{self.docker_filename} at path {docker_file_path}",
+                    code=SNAPCTL_INPUT_ERROR)
+
+                # Run the overrides
+        elif self.subcommand == 'generate-profile':
+            # Setup
+            # self._setup_token_and_token_parts(
+            #     self.base_url, self.api_key, self.byosnap_id)
+            # Validator
+            if not self.out_path:
+                snapctl_error(
+                    message='Missing required parameter: out-path. ' +
+                    'Path is required for profile generation',
                     code=SNAPCTL_INPUT_ERROR)
+            if not os.path.isdir(self.out_path):
+                snapctl_error(
+                    message='Invalid out-path. ' +
+                    'Path should be a directory',
+                    code=SNAPCTL_INPUT_ERROR)
+            if self.profile_filename is not None:
+                if not self.profile_filename.endswith('.json') and \
+                    not self.profile_filename.endswith('.yaml') and \
+                        not self.profile_filename.endswith('.yml'):
+                    snapctl_error(
+                        message='Invalid BYOSnap profile file. Please check the file extension' +
+                        ' and ensure it is either .json, .yaml, or .yml',
+                        code=SNAPCTL_INPUT_ERROR
+                    )
+        elif self.subcommand == 'validate-profile':
+            # # Setup
+            # self._setup_token_and_token_parts(
+            #     self.base_url, self.api_key, self.byosnap_id)
+            # Setup the profile data
+            self._setup_and_validate_byosnap_profile_data()
 
     # Basic methods
 
@@ -812,7 +1128,7 @@ class ByoSnap:
                     with open(swagger_file, "rb") as attachment_file:
                         url = (
                             f"{self.base_url}/v1/snapser-api/byosnaps/"
-                            f"{self.sid}/docs/{self.tag}/openapispec"
+                            f"{self.byosnap_id}/docs/{self.tag}/openapispec"
                         )
                         test_res = requests.post(
                             url, files={"attachment": attachment_file},
@@ -841,7 +1157,7 @@ class ByoSnap:
                     with open(readme_file, "rb") as attachment_file:
                         url = (
                             f"{self.base_url}/v1/snapser-api/byosnaps/"
-                            f"{self.sid}/docs/{self.tag}/markdown"
+                            f"{self.byosnap_id}/docs/{self.tag}/markdown"
                         )
                         test_res = requests.post(
                             url, files={"attachment": attachment_file},
@@ -873,7 +1189,7 @@ class ByoSnap:
                             with open(file_path, "rb") as attachment_file:
                                 url = (
                                     f"{self.base_url}/v1/snapser-api/byosnaps/"
-                                    f"{self.sid}/docs/{self.tag}/tools"
+                                    f"{self.byosnap_id}/docs/{self.tag}/tools"
                                 )
                                 test_res = requests.post(
                                     url, files={"attachment": attachment_file},
@@ -911,7 +1227,7 @@ class ByoSnap:
         progress.add_task(description='Creating your snap...', total=None)
         try:
             payload = {
-                "service_id": self.sid,
+                "service_id": self.byosnap_id,
                 "name": self.name,
                 "description": self.desc,
                 "platform": self.platform_type,
@@ -997,16 +1313,20 @@ class ByoSnap:
         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)
+            profile_data = self._get_profile_contents()
+            dev_template = None
+            if 'dev_template' in profile_data:
+                dev_template = profile_data['dev_template']
+            stage_template = None
+            if 'stage_template' in profile_data:
+                stage_template = profile_data['stage_template']
+            prod_template = None
+            if 'prod_template' in profile_data:
+                prod_template = profile_data['prod_template']
             payload = {
                 "version": self.version,
                 "image_tag": self.tag,
-                "base_url": f"{self.prefix}/{self.sid}",
+                "base_url": f"{self.prefix}/{self.byosnap_id}",
                 "ingress": {
                     "external_port": self.ingress_external_port,
                     "internal_ports": self.ingress_internal_ports
@@ -1015,14 +1335,14 @@ class ByoSnap:
                     "path": self.readiness_path,
                     "initial_delay_seconds": self.readiness_delay
                 },
-                "dev_template": profile_data['dev_template'],
-                "stage_template": profile_data['stage_template'],
-                "prod_template": profile_data['prod_template'],
+                "dev_template": dev_template,
+                "stage_template": stage_template,
+                "prod_template": prod_template,
                 # Currently not supported so we are just hardcoding an empty list
                 "egress": {"ports": []},
             }
             res = requests.post(
-                f"{self.base_url}/v1/snapser-api/byosnaps/{self.sid}/versions",
+                f"{self.base_url}/v1/snapser-api/byosnaps/{self.byosnap_id}/versions",
                 json=payload, headers={'api-key': self.api_key},
                 timeout=SERVER_CALL_TIMEOUT
             )
@@ -1079,7 +1399,7 @@ class ByoSnap:
                 'image_tag': self.tag,
             }
             res = requests.patch(
-                f"{self.base_url}/v1/snapser-api/byosnaps/{self.sid}/versions/{self.version}",
+                f"{self.base_url}/v1/snapser-api/byosnaps/{self.byosnap_id}/versions/{self.version}",
                 json=payload, headers={'api-key': self.api_key},
                 timeout=SERVER_CALL_TIMEOUT
             )
@@ -1127,7 +1447,7 @@ class ByoSnap:
         try:
             # Attempt to create a BYOSnap but no worries if it fails
             payload = {
-                "service_id": self.sid,
+                "service_id": self.byosnap_id,
                 "name": self.name,
                 "description": self.desc,
                 "platform": self.platform_type,
@@ -1152,7 +1472,7 @@ class ByoSnap:
             self.tag = self.version
             # Setup the token and token parts
             self._setup_token_and_token_parts(
-                self.base_url, self.api_key, self.sid)
+                self.base_url, self.api_key, self.byosnap_id)
             # Now publish the image
             self.publish_image(no_exit=True)
             # Now publish the version
@@ -1172,7 +1492,7 @@ class ByoSnap:
             self.tag = f'{self.version}-{int(time.time())}'
             self.publish_image(no_exit=True)
             self.update_version(no_exit=True)
-            byosnap_list: str = f"{self.sid}:{self.version}"
+            byosnap_list: str = f"{self.byosnap_id}:{self.version}"
             snapend = Snapend(
                 subcommand='update', base_url=self.base_url, api_key=self.api_key,
                 snapend_id=self.snapend_id, byosnaps=byosnap_list, blocking=self.blocking
@@ -1184,3 +1504,52 @@ class ByoSnap:
                 message='Exception: Unable to update a ' +
                 f' version for your snap. Exception: {e}',
                 code=SNAPCTL_BYOSNAP_UPDATE_VERSION_ERROR)
+
+    def generate_profile(self, no_exit: bool = False) -> None:
+        """
+            Generate snapser-byosnap-profile.json
+        """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Generating BYOSnap profile...', total=None)
+        try:
+            if self.out_path is not None:
+                file_save_path = os.path.join(
+                    self.out_path, self.profile_filename)
+            else:
+                file_save_path = os.path.join(
+                    os.getcwd(), self.profile_filename)
+            file_written = ByoSnap._handle_output_file(
+                f"{ByoSnap.PROFILE_FILES_PATH}{
+                    self.profile_filename}", file_save_path
+            )
+            if file_written:
+                snapctl_success(
+                    message="BYOSNAP Profile generation successful. " +
+                    f"{self.profile_filename} saved at {
+                        file_save_path}",
+                    progress=progress,
+                    no_exit=no_exit
+                )
+                return
+        except (IOError, OSError) as file_error:
+            snapctl_error(
+                message=f"File error: {file_error}",
+                code=SNAPCTL_BYOSNAP_GENERATE_PROFILE_ERROR, progress=progress)
+        snapctl_error(
+            message="Failed to generate BYOSNAP Profile",
+            code=SNAPCTL_BYOSNAP_GENERATE_PROFILE_ERROR,
+            progress=progress
+        )
+
+    def validate_profile(self) -> None:
+        '''
+        Validate the profile
+        '''
+        # Note all the validation is already happening in the constructor
+        return snapctl_success(message='BYOSNAP profile validated.')