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

snapctl/commands/byogs.py

@@ -8,10 +8,14 @@ import subprocess
 from sys import platform
 from typing import Union
 
+import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from snapctl.types.definitions import ResponseType
+from snapctl.config.constants import SNAPCTL_BYOGS_DEPENDENCY_MISSING, \
+    SNAPCTL_BYOGS_ECR_LOGIN_ERROR, SNAPCTL_BYOGS_BUILD_ERROR, \
+    SNAPCTL_BYOGS_TAG_ERROR, SNAPCTL_BYOGS_PUBLISH_ERROR, \
+    SNAPCTL_BYOGS_PUBLISH_DUPLICATE_TAG_ERROR, SNAPCTL_INPUT_ERROR
 from snapctl.utils.echo import error, success
-from snapctl.utils.helper import get_composite_token
+from snapctl.utils.helper import get_composite_token, snapctl_error, snapctl_success
 
 
 class ByoGs:
@@ -19,7 +23,7 @@ class ByoGs:
         BYOGS CLI commands
     """
     SID = 'byogs'
-    SUBCOMMANDS = ['build', 'push', 'publish']
+    SUBCOMMANDS = ['publish']
     PLATFORMS = ['linux/amd64']
     LANGUAGES = ['go', 'python', 'ruby', 'c#', 'c++', 'rust', 'java', 'node']
     DEFAULT_BUILD_PLATFORM = 'linux/amd64'
@@ -45,6 +49,8 @@ class ByoGs:
         self.input_tag: Union[str, None] = input_tag
         self.path: Union[str, None] = path
         self.dockerfile: str = dockerfile
+        # Validate input
+        self.validate_input()
 
     # Protected methods
 
@@ -70,232 +76,218 @@ class ByoGs:
             pass
         return None
 
-    def _check_dependencies(self) -> bool:
+    def _check_dependencies(self) -> None:
+        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('BYOGS dependencies verified', progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOGS_DEPENDENCY_MISSING, progress)
+        snapctl_error('Docker not running. Please start docker.',
+                      SNAPCTL_BYOGS_DEPENDENCY_MISSING, progress)
 
-    def _docker_login(self) -> bool:
+    def _docker_login(self) -> None:
         # Get the data
         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(
-                        '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('BYOGS ECR login successful', progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress)
+        snapctl_error('BYOGS ECR login failure',
+                      SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress)
 
-    def _docker_build(self) -> bool:
+    def _docker_build(self) -> None:
         # Get the data
-        image_tag = f'{ByoGs.SID}.{self.input_tag}'
-        build_platform = ByoGs.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:
+            image_tag = f'{ByoGs.SID}.{self.input_tag}'
+            build_platform = ByoGs.DEFAULT_BUILD_PLATFORM
+            if len(self.token_parts) == 4:
+                build_platform = self.token_parts[3]
             # 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('BYOGS build successful', progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOGS_BUILD_ERROR, progress)
+        snapctl_error('BYOGS build failure',
+                      SNAPCTL_BYOGS_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'{ByoGs.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:
+            ecr_repo_url = self.token_parts[0]
+            image_tag = f'{ByoGs.SID}.{self.input_tag}'
+            full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
             # 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('BYOGS tag successful', progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOGS_TAG_ERROR, progress)
+        snapctl_error('BYOGS tag failure', SNAPCTL_BYOGS_TAG_ERROR, progress)
 
-    def _docker_push(self) -> bool:
+    def _docker_push(self) -> None:
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Pushing your snap...', total=None)
         try:
             ecr_repo_url = self.token_parts[0]
             image_tag = f'{ByoGs.SID}.{self.input_tag}'
             full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
-
             # Push the image
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                transient=True,
-            ) as progress:
-                progress.add_task(
-                    description='Pushing your snap...', total=None)
-                if platform == "win32":
-                    response = subprocess.run([
-                        'docker', 'push', full_ecr_repo_url
-                    ], shell=True, check=False)
-                    # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
-                else:
-                    response = subprocess.run([
-                        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 platform == "win32":
+                response = subprocess.run([
+                    'docker', 'push', full_ecr_repo_url
+                ], shell=True, check=False)
+                # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            else:
+                response = subprocess.run([
+                    f"docker push {full_ecr_repo_url}"
+                ], shell=True, check=False)
+                # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+            if not response.returncode:
+                return snapctl_success('BYOGS upload successful', progress, no_exit=True)
         except subprocess.CalledProcessError:
-            error('CLI Error')
-            return False
+            snapctl_error('Snapctl Exception',
+                          SNAPCTL_BYOGS_PUBLISH_ERROR, progress)
+        snapctl_error('BYOGS upload failure. Duplicate image error.',
+                      SNAPCTL_BYOGS_PUBLISH_DUPLICATE_TAG_ERROR, progress)
 
     # 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 ByoGs.SUBCOMMANDS:
-            response['msg'] = f"Invalid command. Valid commands are {', '.join(ByoGs.SUBCOMMANDS)}."
-            return response
+            snapctl_error(
+                f"Invalid command. Valid commands are {', '.join(ByoGs.SUBCOMMANDS)}.",
+                SNAPCTL_INPUT_ERROR)
         # Validation for subcommands
         if self.token_parts is None:
-            response['msg'] = 'Invalid token. Please reach out to your support team'
-            return response
+            snapctl_error('Invalid token. Please reach out to your support team',
+                          SNAPCTL_INPUT_ERROR)
         # Check tag
-        if self.input_tag is None or len(self.input_tag.split()) > 1 or \
-                len(self.input_tag) > ByoGs.TAG_CHARACTER_LIMIT:
-            response['msg'] = (
+        if self.input_tag is None:
+            snapctl_error("Missing required parameter:  tag",
+                          SNAPCTL_INPUT_ERROR)
+        if len(self.input_tag.split()) > 1 or len(self.input_tag) > ByoGs.TAG_CHARACTER_LIMIT:
+            snapctl_error(
                 "Tag should be a single word with maximum of "
-                f"{ByoGs.TAG_CHARACTER_LIMIT} characters"
+                f"{ByoGs.TAG_CHARACTER_LIMIT} characters",
+                SNAPCTL_INPUT_ERROR
             )
-            return response
         if self.subcommand in ['build', 'publish']:
-            if not self.input_tag:
-                response['msg'] = "Missing required parameter:  tag"
-                return response
             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
-        # Send success
-        response['error'] = False
-        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)
 
     # 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:
+    def push(self) -> None:
         """
           Tag the image
           1. Check Dependencies
@@ -303,13 +295,13 @@ class ByoGs:
           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()
 
     # Upper echelon commands
-    def publish(self) -> bool:
+    def publish(self) -> None:
         """
           Publish the image
           1. Check Dependencies
@@ -319,7 +311,9 @@ class ByoGs:
           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():
-            return False
-        return True
+        self._check_dependencies()
+        self._docker_login()
+        self._docker_build()
+        self._docker_tag()
+        self._docker_push()
+        snapctl_success('BYOGS publish successful')