snapctl 0.39.2__py3-none-any.whl → 0.41.0__py3-none-any.whl

snapctl/commands/byogs.py

@@ -5,11 +5,13 @@ import base64
 from binascii import Error as BinasciiError
 import os
 import subprocess
+import time
 import platform as sys_platform
 from sys import platform
 from typing import Union, List
 
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from snapctl.commands.snapend import Snapend
 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, \
@@ -24,7 +26,7 @@ class ByoGs:
         BYOGS CLI commands
     """
     SID = 'byogs'
-    SUBCOMMANDS = ['publish']
+    SUBCOMMANDS = ['publish', 'sync']
     PLATFORMS = ['linux/amd64']
     LANGUAGES = ['go', 'python', 'ruby', 'c#', 'c++', 'rust', 'java', 'node']
     DEFAULT_BUILD_PLATFORM = 'linux/amd64'
@@ -32,14 +34,15 @@ class ByoGs:
     TAG_CHARACTER_LIMIT = 80
 
     def __init__(
-        self, subcommand: str, base_url: str, api_key: Union[str, None],
-        input_tag: Union[str, None], path: Union[str, None],
-        resources_path: Union[str, None], dockerfile: str,
-        skip_build: bool = False
+        self, *, subcommand: str, base_url: str, api_key: Union[str, None],
+        tag: Union[str, None] = None, path: Union[str, None] = None,
+        resources_path: Union[str, None] = None, dockerfile: Union[str, None] = None,
+        skip_build: bool = False, snapend_id: Union[str, None] = None,
+        fleet_name: Union[str, None] = None, blocking: bool = False
     ) -> None:
         self.subcommand: str = subcommand
         self.base_url: str = base_url
-        self.api_key: str = api_key
+        self.api_key: Union[str, None] = api_key
         # self.sid: str = sid
         # if subcommand == 'publish':
         #     self.sid = ByoGs.SID
@@ -49,11 +52,14 @@ class ByoGs:
         )
         self.token_parts: Union[List, None] = ByoGs._get_token_values(
             self.token) if self.token is not None else None
-        self.input_tag: Union[str, None] = input_tag
+        self.tag: Union[str, None] = tag
         self.path: Union[str, None] = path
         self.resources_path: Union[str, None] = resources_path
         self.dockerfile: str = dockerfile
         self.skip_build: bool = skip_build
+        self.snapend_id: Union[str, None] = snapend_id
+        self.fleet_name: Union[str, None] = fleet_name
+        self.blocking: bool = blocking
         # Validate input
         self.validate_input()
 
@@ -97,10 +103,14 @@ class ByoGs:
                 "docker", "info"
             ], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
             if not result.returncode:
-                return snapctl_success('BYOGS dependencies verified', progress, no_exit=True)
+                return snapctl_success(
+                    message='BYOGS dependencies verified',
+                    progress=progress, no_exit=True)
         except subprocess.CalledProcessError:
             snapctl_error('Snapctl Exception',
                           SNAPCTL_BYOGS_DEPENDENCY_MISSING, progress)
+        finally:
+            progress.stop()
         snapctl_error('Docker not running. Please start docker.',
                       SNAPCTL_BYOGS_DEPENDENCY_MISSING, progress)
 
@@ -130,12 +140,17 @@ class ByoGs:
                     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)
+                return snapctl_success(
+                    message='BYOGS ECR login successful', progress=progress, no_exit=True)
         except subprocess.CalledProcessError:
-            snapctl_error('Snapctl Exception',
-                          SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress)
-        snapctl_error('BYOGS ECR login failure',
-                      SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress)
+            snapctl_error(
+                message='Snapctl Exception',
+                code=SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='BYOGS ECR login failure',
+            code=SNAPCTL_BYOGS_ECR_LOGIN_ERROR, progress=progress)
 
     def _docker_build(self) -> None:
         # Get the data
@@ -148,7 +163,7 @@ class ByoGs:
         progress.add_task(
             description='Building your snap...', total=None)
         try:
-            # image_tag = f'{ByoGs.SID}.{self.input_tag}'
+            # image_tag = f'{ByoGs.SID}.{self.tag}'
             build_platform = ByoGs.DEFAULT_BUILD_PLATFORM
             if len(self.token_parts) == 4:
                 build_platform = self.token_parts[3]
@@ -169,7 +184,7 @@ class ByoGs:
             if platform == "win32":
                 response = subprocess.run([
                     # f"docker build --no-cache -t {tag} {path}"
-                    'docker', 'build', '--platform', build_platform, '-t', self.input_tag,
+                    'docker', 'build', '--platform', build_platform, '-t', self.tag,
                     '-f', docker_file_path,  self.path
                 ], shell=True, check=False)
                 # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
@@ -177,17 +192,23 @@ class ByoGs:
                 response = subprocess.run([
                     # f"docker build --no-cache -t {tag} {path}"
                     "docker build --platform " +
-                    f"{build_platform} -t {self.input_tag} " +
+                    f"{build_platform} -t {self.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)
+                return snapctl_success(
+                    message='BYOGS build successful',
+                    progress=progress, no_exit=True)
         except subprocess.CalledProcessError:
-            snapctl_error('Snapctl Exception',
-                          SNAPCTL_BYOGS_BUILD_ERROR, progress)
-        snapctl_error('BYOGS build failure',
-                      SNAPCTL_BYOGS_BUILD_ERROR, progress)
+            snapctl_error(
+                message='Snapctl Exception',
+                code=SNAPCTL_BYOGS_BUILD_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='BYOGS build failure',
+            code=SNAPCTL_BYOGS_BUILD_ERROR, progress=progress)
 
     def _docker_tag(self) -> None:
         # Get the data
@@ -201,23 +222,28 @@ class ByoGs:
             description='Tagging your snap...', total=None)
         try:
             ecr_repo_url = self.token_parts[0]
-            image_tag = f'{ByoGs.SID}.{self.input_tag}'
+            image_tag = f'{ByoGs.SID}.{self.tag}'
             full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
             # Tag the repo
             if platform == "win32":
                 response = subprocess.run([
-                    'docker', 'tag', self.input_tag, full_ecr_repo_url
+                    'docker', 'tag', self.tag, full_ecr_repo_url
                 ], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False)
             else:
                 response = subprocess.run([
-                    f"docker tag {self.input_tag} {full_ecr_repo_url}"
+                    f"docker tag {self.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)
+                return snapctl_success(
+                    message='BYOGS tag successful', progress=progress, no_exit=True)
         except subprocess.CalledProcessError:
-            snapctl_error('Snapctl Exception',
-                          SNAPCTL_BYOGS_TAG_ERROR, progress)
-        snapctl_error('BYOGS tag failure', SNAPCTL_BYOGS_TAG_ERROR, progress)
+            snapctl_error(
+                message='Snapctl Exception',
+                code=SNAPCTL_BYOGS_TAG_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='BYOGS tag failure', code=SNAPCTL_BYOGS_TAG_ERROR, progress=progress)
 
     def _docker_push(self) -> None:
         progress = Progress(
@@ -230,7 +256,7 @@ class ByoGs:
             description='Pushing your snap...', total=None)
         try:
             ecr_repo_url = self.token_parts[0]
-            image_tag = f'{ByoGs.SID}.{self.input_tag}'
+            image_tag = f'{ByoGs.SID}.{self.tag}'
             full_ecr_repo_url = f'{ecr_repo_url}:{image_tag}'
             # Push the image
             if platform == "win32":
@@ -244,12 +270,49 @@ class ByoGs:
                 ], shell=True, check=False)
                 # stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
             if not response.returncode:
-                return snapctl_success('BYOGS upload successful', progress, no_exit=True)
+                return snapctl_success(
+                    message='BYOGS upload successful',
+                    progress=progress, no_exit=True)
         except subprocess.CalledProcessError:
-            snapctl_error('Snapctl Exception',
-                          SNAPCTL_BYOGS_PUBLISH_ERROR, progress)
-        snapctl_error('BYOGS upload failure. Duplicate image error.',
-                      SNAPCTL_BYOGS_PUBLISH_DUPLICATE_TAG_ERROR, progress)
+            snapctl_error(
+                message='Snapctl Exception',
+                code=SNAPCTL_BYOGS_PUBLISH_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='BYOGS upload failure. Duplicate image error.',
+            code=SNAPCTL_BYOGS_PUBLISH_DUPLICATE_TAG_ERROR, progress=progress)
+
+    def _clean_slate(self) -> None:
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Cleaning cache and initializing...', total=None)
+        try:
+            # Specific ECR repository URL to check against
+            ecr_repo_url = self.token_parts[0]
+            if platform == "win32":
+                # Perform the Docker logout
+                logout_response = subprocess.run(
+                    ['docker', 'logout', ecr_repo_url],
+                    shell=True, check=False)
+            else:
+                # Perform the Docker logout
+                logout_response = subprocess.run([
+                    f"docker logout {ecr_repo_url}"
+                ], shell=True, check=False)
+            if not logout_response.returncode:
+                return snapctl_success(
+                    message='Cleanup complete',
+                    progress=progress, no_exit=True)
+        except subprocess.CalledProcessError:
+            warning('Unable to initialize with a clean slate.')
+        finally:
+            progress.stop()
 
     # Public methods
 
@@ -260,31 +323,51 @@ class ByoGs:
         """
         # Check API Key and Base URL
         if not self.api_key or self.base_url == '':
-            snapctl_error("Missing API Key.", SNAPCTL_INPUT_ERROR)
+            snapctl_error(
+                message="Missing API Key.", code=SNAPCTL_INPUT_ERROR)
         # Check subcommand
         if not self.subcommand in ByoGs.SUBCOMMANDS:
             snapctl_error(
-                "Invalid command. Valid commands are " +
+                message="Invalid command. Valid commands are " +
                 f"{', '.join(ByoGs.SUBCOMMANDS)}.",
-                SNAPCTL_INPUT_ERROR)
+                code=SNAPCTL_INPUT_ERROR)
         # Validation for subcommands
         if self.token_parts is None:
-            snapctl_error('Invalid token. Please reach out to your support team',
-                          SNAPCTL_INPUT_ERROR)
+            snapctl_error(
+                message='Invalid token. Please reach out to your support team',
+                code=SNAPCTL_INPUT_ERROR)
         # Check tag
-        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:
+        if self.tag is None:
+            snapctl_error(
+                message="Missing required parameter:  tag",
+                code=SNAPCTL_INPUT_ERROR)
+        if len(self.tag.split()) > 1 or len(self.tag) > ByoGs.TAG_CHARACTER_LIMIT:
             snapctl_error(
-                "Tag should be a single word with maximum of " +
+                message="Tag should be a single word with maximum of " +
                 f"{ByoGs.TAG_CHARACTER_LIMIT} characters",
-                SNAPCTL_INPUT_ERROR
+                code=SNAPCTL_INPUT_ERROR
             )
         if self.subcommand in ['build', 'publish']:
             if not self.skip_build and not self.path:
-                snapctl_error("Missing required parameter:  path",
-                              SNAPCTL_INPUT_ERROR)
+                snapctl_error(
+                    message="Missing required parameter:  path",
+                    code=SNAPCTL_INPUT_ERROR)
+            # Check path
+            if self.resources_path:
+                docker_file_path = f"{self.resources_path}/{self.dockerfile}"
+            else:
+                docker_file_path = f"{self.path}/{self.dockerfile}"
+
+            if not self.skip_build and not os.path.isfile(docker_file_path):
+                snapctl_error(
+                    message="Unable to find " +
+                    f"{self.dockerfile} at path {docker_file_path}",
+                    code=SNAPCTL_INPUT_ERROR)
+        elif self.subcommand == 'sync':
+            if not self.skip_build and not self.path:
+                snapctl_error(
+                    message="Missing required parameter:  path",
+                    code=SNAPCTL_INPUT_ERROR)
             # Check path
             if self.resources_path:
                 docker_file_path = f"{self.resources_path}/{self.dockerfile}"
@@ -293,13 +376,17 @@ class ByoGs:
 
             if not self.skip_build and not os.path.isfile(docker_file_path):
                 snapctl_error(
-                    "Unable to find " +
+                    message="Unable to find " +
                     f"{self.dockerfile} at path {docker_file_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)
+                    code=SNAPCTL_INPUT_ERROR)
+            if not self.snapend_id:
+                snapctl_error(
+                    message="Missing required parameter: snapend_id",
+                    code=SNAPCTL_INPUT_ERROR)
+            if not self.fleet_name:
+                snapctl_error(
+                    message="Missing required parameter: fleet_name",
+                    code=SNAPCTL_INPUT_ERROR)
 
     # CRUD methods
     def build(self) -> None:
@@ -322,11 +409,12 @@ class ByoGs:
         """
         self._check_dependencies()
         self._docker_tag()
+        self._clean_slate()
         self._docker_login()
         self._docker_push()
 
     # Upper echelon commands
-    def publish(self) -> None:
+    def publish(self, no_exit: bool = False) -> None:
         """
           Publish the image
           1. Check Dependencies
@@ -342,6 +430,28 @@ class ByoGs:
         else:
             info('--skip-build set. Skipping the build step.')
         self._docker_tag()
+        self._clean_slate()
         self._docker_login()
         self._docker_push()
-        snapctl_success('BYOGS publish successful')
+        snapctl_success(
+            message='BYOGS publish successful', no_exit=no_exit)
+
+    def sync(self) -> None:
+        """
+          Sync the image
+          1. Check Dependencies
+          2. Login to Snapser Registry
+          3. Build your snap
+          4. Tag the repo
+          5. Push the image
+          6. Upload swagger.json
+        """
+        self.tag = f'{self.tag}-{int(time.time())}'
+        self.publish(no_exit=True)
+        byogs_list: str = f"{self.fleet_name}:{self.tag}"
+        snapend = Snapend(
+            subcommand='update', base_url=self.base_url, api_key=self.api_key,
+            snapend_id=self.snapend_id, byogs=byogs_list, blocking=self.blocking
+        )
+        snapend.update(no_exit=True)
+        return snapctl_success(message='BYOGs sync successful')