snowflake-cli 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/entities/application.py

@@ -41,7 +41,7 @@ from snowflake.cli._plugins.nativeapp.same_account_install_method import (
     SameAccountInstallMethod,
 )
 from snowflake.cli._plugins.nativeapp.utils import needs_confirmation
-from snowflake.cli._plugins.workspace.action_context import ActionContext
+from snowflake.cli._plugins.workspace.context import ActionContext
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
@@ -53,8 +53,10 @@ from snowflake.cli.api.entities.utils import (
 )
 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,
+    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
     NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
     ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
 )
@@ -70,6 +72,7 @@ from snowflake.cli.api.project.util import (
     append_test_resource_suffix,
     extract_schema,
     identifier_for_url,
+    to_identifier,
     unquote_identifier,
 )
 from snowflake.connector import DictCursor, ProgrammingError
@@ -118,7 +121,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
 
     def action_deploy(
         self,
-        ctx: ActionContext,
+        action_ctx: ActionContext,
         from_release_directive: bool,
         prune: bool,
         recursive: bool,
@@ -133,18 +136,21 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         **kwargs,
     ):
         model = self._entity_model
+        workspace_ctx = self._workspace_ctx
         app_name = model.fqn.identifier
         debug_mode = model.debug
         if model.meta:
-            app_role = model.meta.role or ctx.default_role
-            app_warehouse = model.meta.warehouse or ctx.default_warehouse
+            app_role = model.meta.role or workspace_ctx.default_role
+            app_warehouse = model.meta.warehouse or workspace_ctx.default_warehouse
             post_deploy_hooks = model.meta.post_deploy
         else:
-            app_role = ctx.default_role
-            app_warehouse = ctx.default_warehouse
+            app_role = workspace_ctx.default_role
+            app_warehouse = workspace_ctx.default_warehouse
             post_deploy_hooks = None
 
-        package_entity: ApplicationPackageEntity = ctx.get_entity(model.from_.target)
+        package_entity: ApplicationPackageEntity = action_ctx.get_entity(
+            model.from_.target
+        )
         package_model: ApplicationPackageEntityModel = (
             package_entity._entity_model  # noqa: SLF001
         )
@@ -152,7 +158,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         if package_model.meta and package_model.meta.role:
             package_role = package_model.meta.role
         else:
-            package_role = ctx.default_role
+            package_role = workspace_ctx.default_role
 
         if not stage_fqn:
             stage_fqn = f"{package_name}.{package_model.stage}"
@@ -169,7 +175,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
 
         def deploy_package():
             package_entity.action_deploy(
-                ctx=ctx,
+                action_ctx=action_ctx,
                 prune=True,
                 recursive=True,
                 paths=[],
@@ -179,9 +185,19 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 force=force,
             )
 
+        def drop_application_before_upgrade(cascade: bool = False):
+            self.drop_application_before_upgrade(
+                console=workspace_ctx.console,
+                app_name=app_name,
+                app_role=app_role,
+                policy=policy,
+                is_interactive=is_interactive,
+                cascade=cascade,
+            )
+
         self.deploy(
-            console=ctx.console,
-            project_root=ctx.project_root,
+            console=workspace_ctx.console,
+            project_root=workspace_ctx.project_root,
             app_name=app_name,
             app_role=app_role,
             app_warehouse=app_warehouse,
@@ -198,11 +214,12 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             patch=patch,
             post_deploy_hooks=post_deploy_hooks,
             deploy_package=deploy_package,
+            drop_application_before_upgrade=drop_application_before_upgrade,
         )
 
     def action_drop(
         self,
-        ctx: ActionContext,
+        action_ctx: ActionContext,
         interactive: bool,
         force_drop: bool = False,
         cascade: Optional[bool] = None,
@@ -210,13 +227,14 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         **kwargs,
     ):
         model = self._entity_model
+        workspace_ctx = self._workspace_ctx
         app_name = model.fqn.identifier
         if model.meta and model.meta.role:
             app_role = model.meta.role
         else:
-            app_role = ctx.default_role
+            app_role = workspace_ctx.default_role
         self.drop(
-            console=ctx.console,
+            console=workspace_ctx.console,
             app_name=app_name,
             app_role=app_role,
             auto_yes=force_drop,
@@ -224,6 +242,58 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             cascade=cascade,
         )
 
+    def action_events(
+        self,
+        action_ctx: ActionContext,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        record_types: list[str] | None = None,
+        scopes: list[str] | None = None,
+        consumer_org: str = "",
+        consumer_account: str = "",
+        consumer_app_hash: str = "",
+        first: int = -1,
+        last: int = -1,
+        follow: bool = False,
+        interval_seconds: int = 10,
+        *args,
+        **kwargs,
+    ):
+        model = self._entity_model
+        package_entity: ApplicationPackageEntity = action_ctx.get_entity(
+            model.from_.target
+        )
+        package_model: ApplicationPackageEntityModel = (
+            package_entity._entity_model  # noqa: SLF001
+        )
+        if follow:
+            return self.stream_events(
+                app_name=model.fqn.identifier,
+                package_name=package_model.fqn.identifier,
+                interval_seconds=interval_seconds,
+                since=since,
+                record_types=record_types,
+                scopes=scopes,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+                last=last,
+            )
+        else:
+            return self.get_events(
+                app_name=model.fqn.identifier,
+                package_name=package_model.fqn.identifier,
+                since=since,
+                until=until,
+                record_types=record_types,
+                scopes=scopes,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+                first=first,
+                last=last,
+            )
+
     @classmethod
     def drop(
         cls,
@@ -241,7 +311,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         needs_confirm = True
 
         # 1. If existing application is not found, exit gracefully
-        show_obj_row = cls.get_existing_app_info(
+        show_obj_row = cls.get_existing_app_info_static(
             app_name=app_name,
             app_role=app_role,
         )
@@ -531,7 +601,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             with sql_executor.use_warehouse(app_warehouse):
 
                 # 2. Check for an existing application by the same name
-                show_app_row = cls.get_existing_app_info(
+                show_app_row = cls.get_existing_app_info_static(
                     app_name=app_name,
                     app_role=app_role,
                 )
@@ -674,11 +744,15 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 )
             )
 
+    def get_existing_app_info(self) -> Optional[dict]:
+        model = self._entity_model
+        ctx = self._workspace_ctx
+        role = (model.meta and model.meta.role) or ctx.default_role
+        return self.get_existing_app_info_static(model.fqn.name, role)
+
+    # Temporary static entrypoint until NativeAppManager.get_existing_app_info() is removed
     @staticmethod
-    def get_existing_app_info(
-        app_name: str,
-        app_role: str,
-    ) -> Optional[dict]:
+    def get_existing_app_info_static(app_name: str, app_role: str) -> Optional[dict]:
         """
         Check for an existing application object by the same name as in project definition, in account.
         It executes a 'show applications like' query and returns the result as single row, if one exists.
@@ -689,6 +763,66 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
                 "applications", app_name, name_col=NAME_COL
             )
 
+    @classmethod
+    def drop_application_before_upgrade(
+        cls,
+        console: AbstractConsole,
+        app_name: str,
+        app_role: str,
+        policy: PolicyBase,
+        is_interactive: bool,
+        cascade: bool = False,
+    ):
+        if cascade:
+            try:
+                if application_objects := cls.get_objects_owned_by_application(
+                    app_name, app_role
+                ):
+                    application_objects_str = cls.application_objects_to_str(
+                        application_objects
+                    )
+                    console.message(
+                        f"The following objects are owned by application {app_name} and need to be dropped:\n{application_objects_str}"
+                    )
+            except ProgrammingError as err:
+                if err.errno != APPLICATION_NO_LONGER_AVAILABLE:
+                    generic_sql_error_handler(err)
+                console.warning(
+                    "The application owns other objects but they could not be determined."
+                )
+            user_prompt = "Do you want the Snowflake CLI to drop these objects, then drop the existing application object and recreate it?"
+        else:
+            user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
+
+        if not policy.should_proceed(user_prompt):
+            if is_interactive:
+                console.message("Not upgrading the application object.")
+                raise typer.Exit(0)
+            else:
+                console.message(
+                    "Cannot upgrade the application object non-interactively without --force."
+                )
+                raise typer.Exit(1)
+        try:
+            cascade_msg = " (cascade)" if cascade else ""
+            console.step(f"Dropping application object {app_name}{cascade_msg}.")
+            cascade_sql = " cascade" if cascade else ""
+            sql_executor = get_sql_executor()
+            sql_executor.execute_query(f"drop application {app_name}{cascade_sql}")
+        except ProgrammingError as err:
+            if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS and not cascade:
+                # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)
+                return cls.drop_application_before_upgrade(
+                    console=console,
+                    app_name=app_name,
+                    app_role=app_role,
+                    policy=policy,
+                    is_interactive=is_interactive,
+                    cascade=True,
+                )
+            else:
+                generic_sql_error_handler(err)
+
     @classmethod
     def get_events(
         cls,
@@ -704,7 +838,6 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         first: int = -1,
         last: int = -1,
     ):
-
         record_types = record_types or []
         scopes = scopes or []
 
@@ -712,7 +845,7 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
             raise ValueError("first and last cannot be used together")
 
         account_event_table = cls.get_account_event_table()
-        if not account_event_table:
+        if not account_event_table or account_event_table == "NONE":
             raise NoEventTableForAccount()
 
         # resource_attributes uses the unquoted/uppercase app and package name
@@ -787,7 +920,16 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         try:
             return sql_executor.execute_query(query, cursor_class=DictCursor).fetchall()
         except ProgrammingError as err:
-            generic_sql_error_handler(err)
+            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
+                raise ClickException(
+                    dedent(
+                        f"""\
+                    Event table '{account_event_table}' does not exist or you are not authorized to perform this operation.
+                    Please check your EVENT_TABLE parameter to ensure that it is set to a valid event table."""
+                    )
+                ) from err
+            else:
+                generic_sql_error_handler(err)
 
     @classmethod
     def stream_events(
@@ -846,8 +988,18 @@ class ApplicationEntity(EntityBase[ApplicationEntityModel]):
         results = sql_executor.execute_query(query, cursor_class=DictCursor)
         return next((r["value"] for r in results if r["key"] == "EVENT_TABLE"), "")
 
+    def get_snowsight_url(self) -> str:
+        """Returns the URL that can be used to visit this app via Snowsight."""
+        model = self._entity_model
+        ctx = self._workspace_ctx
+        warehouse = (
+            model.meta and model.meta.warehouse and to_identifier(model.meta.warehouse)
+        ) or to_identifier(ctx.default_warehouse)
+        return self.get_snowsight_url_static(model.fqn.name, warehouse)
+
+    # Temporary static entrypoint until NativeAppManager.get_snowsight_url() is removed
     @classmethod
-    def get_snowsight_url(cls, app_name: str, app_warehouse: str | None) -> str:
+    def get_snowsight_url_static(cls, app_name: str, app_warehouse: str) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
         name = identifier_for_url(app_name)
         with cls.use_application_warehouse(app_warehouse):