snowflake-cli-labs 3.0.0rc0__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/run_processor.py

@@ -15,135 +15,33 @@
 from __future__ import annotations
 
 from pathlib import Path
-from textwrap import dedent
 from typing import Optional
 
 import typer
-from click import UsageError
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
-from snowflake.cli._plugins.nativeapp.constants import (
-    ALLOWED_SPECIAL_COMMENTS,
-    COMMENT_COL,
-    PATCH_COL,
-    SPECIAL_COMMENT,
-    VERSION_COL,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationCreatedExternallyError,
-    ApplicationPackageDoesNotExistError,
-)
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
 from snowflake.cli._plugins.nativeapp.policy import PolicyBase
-from snowflake.cli._plugins.nativeapp.project_model import (
-    NativeAppProjectModel,
+from snowflake.cli._plugins.nativeapp.same_account_install_method import (
+    SameAccountInstallMethod,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.application_entity import (
+    ApplicationEntity,
+)
 from snowflake.cli.api.entities.utils import (
-    ensure_correct_owner,
     generic_sql_error_handler,
 )
 from snowflake.cli.api.errno import (
     APPLICATION_NO_LONGER_AVAILABLE,
     APPLICATION_OWNS_EXTERNAL_OBJECTS,
-    CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
-    CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES,
-    NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
-from snowflake.cli.api.project.util import (
-    identifier_to_show_like_pattern,
-    unquote_identifier,
-)
-from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor, SnowflakeCursor
-
-# Reasons why an `alter application ... upgrade` might fail
-UPGRADE_RESTRICTION_CODES = {
-    CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
-    CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES,
-    ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    APPLICATION_NO_LONGER_AVAILABLE,
-}
-
-
-def print_messages(create_or_upgrade_cursor: Optional[SnowflakeCursor]):
-    """
-    Shows messages in the console returned by the CREATE or UPGRADE
-    APPLICATION command.
-    """
-    if not create_or_upgrade_cursor:
-        return
-
-    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
-    for message in messages:
-        cc.warning(message)
-    cc.message("")
-
-
-class SameAccountInstallMethod:
-    _requires_created_by_cli: bool
-    _from_release_directive: bool
-    version: Optional[str]
-    patch: Optional[int]
-
-    def __init__(
-        self,
-        requires_created_by_cli: bool,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
-        from_release_directive: bool = False,
-    ):
-        self._requires_created_by_cli = requires_created_by_cli
-        self.version = version
-        self.patch = patch
-        self._from_release_directive = from_release_directive
-
-    @classmethod
-    def unversioned_dev(cls):
-        """aka. stage dev aka loose files"""
-        return cls(True)
-
-    @classmethod
-    def versioned_dev(cls, version: str, patch: Optional[int] = None):
-        return cls(False, version, patch)
-
-    @classmethod
-    def release_directive(cls):
-        return cls(False, from_release_directive=True)
-
-    @property
-    def is_dev_mode(self) -> bool:
-        return not self._from_release_directive
-
-    def using_clause(self, app: NativeAppProjectModel) -> str:
-        if self._from_release_directive:
-            return ""
-
-        if self.version:
-            patch_clause = f"patch {self.patch}" if self.patch else ""
-            return f"using version {self.version} {patch_clause}"
-
-        stage_name = StageManager.quote_stage_name(app.stage_fqn)
-        return f"using {stage_name}"
-
-    def ensure_app_usable(self, app: NativeAppProjectModel, show_app_row: dict):
-        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
-
-        if self._requires_created_by_cli:
-            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
-                # this application object was not created by this tooling
-                raise ApplicationCreatedExternallyError(app.app_name)
-
-        # expected owner
-        ensure_correct_owner(row=show_app_row, role=app.app_role, obj_name=app.app_name)
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
@@ -165,35 +63,11 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
             return show_obj_cursor
 
     def get_existing_version_info(self, version: str) -> Optional[dict]:
-        """
-        Get the latest patch on an existing version by name in the application package.
-        Executes 'show versions like ... in application package' query and returns
-        the latest patch in the version as a single row, if one exists. Otherwise,
-        returns None.
-        """
-        with self.use_role(self.package_role):
-            try:
-                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {self.package_name}"
-                cursor = self._execute_query(query, cursor_class=DictCursor)
-
-                if cursor.rowcount is None:
-                    raise SnowflakeSQLExecutionError(query)
-
-                matching_rows = find_all_rows(
-                    cursor, lambda row: row[VERSION_COL] == unquote_identifier(version)
-                )
-
-                if not matching_rows:
-                    return None
-
-                return max(matching_rows, key=lambda row: row[PATCH_COL])
-
-            except ProgrammingError as err:
-                if err.msg.__contains__("does not exist or not authorized"):
-                    raise ApplicationPackageDoesNotExistError(self.package_name)
-                else:
-                    generic_sql_error_handler(err=err, role=self.package_role)
-                    return None
+        return ApplicationEntity.get_existing_version_info(
+            version=version,
+            package_name=self.package_name,
+            package_role=self.package_role,
+        )
 
     def drop_application_before_upgrade(
         self, policy: PolicyBase, is_interactive: bool, cascade: bool = False
@@ -249,90 +123,26 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         install_method: SameAccountInstallMethod,
         is_interactive: bool = False,
     ):
-        with self.use_role(self.app_role):
-
-            # 1. Need to use a warehouse to create an application object
-            with self.use_warehouse(self.application_warehouse):
-
-                # 2. Check for an existing application by the same name
-                show_app_row = self.get_existing_app_info()
-
-                # 3. If existing application is found, perform a few validations and upgrade the application object.
-                if show_app_row:
-
-                    install_method.ensure_app_usable(self._na_project, show_app_row)
-
-                    # If all the above checks are in order, proceed to upgrade
-                    try:
-                        cc.step(
-                            f"Upgrading existing application object {self.app_name}."
-                        )
-                        using_clause = install_method.using_clause(self._na_project)
-                        upgrade_cursor = self._execute_query(
-                            f"alter application {self.app_name} upgrade {using_clause}",
-                        )
-                        print_messages(upgrade_cursor)
-
-                        if install_method.is_dev_mode:
-                            # if debug_mode is present (controlled), ensure it is up-to-date
-                            if self.debug_mode is not None:
-                                self._execute_query(
-                                    f"alter application {self.app_name} set debug_mode = {self.debug_mode}"
-                                )
-
-                        # hooks always executed after a create or upgrade
-                        self.execute_app_post_deploy_hooks()
-                        return
-
-                    except ProgrammingError as err:
-                        if err.errno not in UPGRADE_RESTRICTION_CODES:
-                            generic_sql_error_handler(err=err)
-                        else:  # The existing application object was created from a different process.
-                            cc.warning(err.msg)
-                            self.drop_application_before_upgrade(policy, is_interactive)
-
-                # 4. With no (more) existing application objects, create an application object using the release directives
-                cc.step(f"Creating new application object {self.app_name} in account.")
-
-                if self.app_role != self.package_role:
-                    with self.use_role(self.package_role):
-                        self._execute_query(
-                            f"grant install, develop on application package {self.package_name} to role {self.app_role}"
-                        )
-                        self._execute_query(
-                            f"grant usage on schema {self.package_name}.{self.stage_schema} to role {self.app_role}"
-                        )
-                        self._execute_query(
-                            f"grant read on stage {self.stage_fqn} to role {self.app_role}"
-                        )
-
-                try:
-                    # by default, applications are created in debug mode when possible;
-                    # this can be overridden in the project definition
-                    debug_mode_clause = ""
-                    if install_method.is_dev_mode:
-                        initial_debug_mode = (
-                            self.debug_mode if self.debug_mode is not None else True
-                        )
-                        debug_mode_clause = f"debug_mode = {initial_debug_mode}"
-
-                    using_clause = install_method.using_clause(self._na_project)
-                    create_cursor = self._execute_query(
-                        dedent(
-                            f"""\
-                        create application {self.app_name}
-                            from application package {self.package_name} {using_clause} {debug_mode_clause}
-                            comment = {SPECIAL_COMMENT}
-                        """
-                        ),
-                    )
-                    print_messages(create_cursor)
-
-                    # hooks always executed after a create or upgrade
-                    self.execute_app_post_deploy_hooks()
-
-                except ProgrammingError as err:
-                    generic_sql_error_handler(err)
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        return ApplicationEntity.create_or_upgrade_app(
+            console=cc,
+            project_root=self.project_root,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            policy=policy,
+            install_method=install_method,
+            is_interactive=is_interactive,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            drop_application_before_upgrade=drop_app,
+        )
 
     def process(
         self,
@@ -346,46 +156,32 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         *args,
         **kwargs,
     ):
-        """
-        Create or upgrade the application object using the given strategy
-        (unversioned dev, versioned dev, or same-account release directive).
-        """
-
-        # same-account release directive
-        if from_release_directive:
-            self.create_or_upgrade_app(
-                policy=policy,
-                is_interactive=is_interactive,
-                install_method=SameAccountInstallMethod.release_directive(),
+        def deploy_package():
+            self.deploy(
+                bundle_map=bundle_map, prune=True, recursive=True, validate=validate
             )
-            return
 
-        # versioned dev
-        if version:
-            try:
-                version_exists = self.get_existing_version_info(version)
-                if not version_exists:
-                    raise UsageError(
-                        f"Application package {self.package_name} does not have any version {version} defined. Use 'snow app version create' to define a version in the application package first."
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise UsageError(
-                    f"Application package {self.package_name} does not exist. Use 'snow app version create' to first create an application package and then define a version in it."
-                )
-
-            self.create_or_upgrade_app(
-                policy=policy,
-                install_method=SameAccountInstallMethod.versioned_dev(version, patch),
-                is_interactive=is_interactive,
-            )
-            return
-
-        # unversioned dev
-        self.deploy(
-            bundle_map=bundle_map, prune=True, recursive=True, validate=validate
-        )
-        self.create_or_upgrade_app(
-            policy=policy,
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        ApplicationEntity.deploy(
+            console=cc,
+            project_root=self.project_root,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            validate=validate,
+            from_release_directive=from_release_directive,
             is_interactive=is_interactive,
-            install_method=SameAccountInstallMethod.unversioned_dev(),
+            policy=policy,
+            version=version,
+            patch=patch,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            deploy_package=deploy_package,
+            drop_application_before_upgrade=drop_app,
         )

snowflake/cli/_plugins/nativeapp/same_account_install_method.py

@@ -0,0 +1,74 @@
+from typing import Optional
+
+from snowflake.cli._plugins.nativeapp.constants import (
+    ALLOWED_SPECIAL_COMMENTS,
+    COMMENT_COL,
+)
+from snowflake.cli._plugins.nativeapp.exceptions import (
+    ApplicationCreatedExternallyError,
+)
+
+# from snowflake.cli._plugins.nativeapp.project_model import NativeAppProjectModel
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.entities.utils import ensure_correct_owner
+
+
+class SameAccountInstallMethod:
+    _requires_created_by_cli: bool
+    _from_release_directive: bool
+    version: Optional[str]
+    patch: Optional[int]
+
+    def __init__(
+        self,
+        requires_created_by_cli: bool,
+        version: Optional[str] = None,
+        patch: Optional[int] = None,
+        from_release_directive: bool = False,
+    ):
+        self._requires_created_by_cli = requires_created_by_cli
+        self.version = version
+        self.patch = patch
+        self._from_release_directive = from_release_directive
+
+    @classmethod
+    def unversioned_dev(cls):
+        """aka. stage dev aka loose files"""
+        return cls(True)
+
+    @classmethod
+    def versioned_dev(cls, version: str, patch: Optional[int] = None):
+        return cls(False, version, patch)
+
+    @classmethod
+    def release_directive(cls):
+        return cls(False, from_release_directive=True)
+
+    @property
+    def is_dev_mode(self) -> bool:
+        return not self._from_release_directive
+
+    def using_clause(
+        self,
+        stage_fqn: str,
+    ) -> str:
+        if self._from_release_directive:
+            return ""
+
+        if self.version:
+            patch_clause = f"patch {self.patch}" if self.patch else ""
+            return f"using version {self.version} {patch_clause}"
+
+        stage_name = StageManager.quote_stage_name(stage_fqn)
+        return f"using {stage_name}"
+
+    def ensure_app_usable(self, app_name: str, app_role: str, show_app_row: dict):
+        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
+
+        if self._requires_created_by_cli:
+            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
+                # this application object was not created by this tooling
+                raise ApplicationCreatedExternallyError(app_name)
+
+        # expected owner
+        ensure_correct_owner(row=show_app_row, role=app_role, obj_name=app_name)