Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

refactor(api): migrate explore task stop admission (#41874)

非法操作9daff34bb596
diff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.py
index cad51cd0454..4a5d59b7ac7 100644
--- a/api/controllers/console/explore/completion.py
+++ b/api/controllers/console/explore/completion.py
@@ -2,6 +2,7 @@ import logging
from typing import Any, Literal
from uuid import UUID
+from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator
from sqlalchemy.orm import Session
from werkzeug.exceptions import InternalServerError, NotFound
@@ -19,8 +20,10 @@ from controllers.console.app.error import (
)
from controllers.console.app.wraps import with_session
from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
+from controllers.console.explore.installed_app_admission import get_installed_app
from controllers.console.explore.wraps import InstalledAppResource
-from controllers.console.wraps import model_validate, with_current_user, with_current_user_id
+from controllers.console.flask_admission import console_account_admission
+from controllers.console.wraps import model_validate, with_current_user
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from core.app.entities.app_invoke_entities import InvokeFrom
from core.errors.error import (
@@ -28,16 +31,20 @@ from core.errors.error import (
ProviderTokenNotInitError,
QuotaExceededError,
)
+from extensions.ext_application_services import application_services
from extensions.ext_database import db
from graphon.model_runtime.errors.invoke import InvokeError
from libs import helper
from libs.datetime_utils import naive_utc_now
+from machinery.context import RequestContext
from models import Account
from models.model import AppMode, InstalledApp
+from services.app_definition_query_service import AppDefinitionUnavailableError
from services.app_generate_service import AppGenerateService
from services.app_task_service import AppTaskService
from services.conversation_service import ConversationService
from services.errors.llm import InvokeRateLimitError
+from services.installed_app_access_service import InstalledAppRef
from .. import console_ns
@@ -149,22 +156,25 @@ class CompletionApi(InstalledAppResource):
"/installed-apps/<uuid:installed_app_id>/completion-messages/<string:task_id>/stop",
endpoint="installed_app_stop_completion",
)
-class CompletionStopApi(InstalledAppResource):
+class CompletionStopApi(Resource):
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
- @with_current_user_id
- @with_session(write=False)
- def post(self, session: Session, current_user_id: str, installed_app: InstalledApp, task_id: str):
- app_model = installed_app.app_with_session(session=session)
- if app_model is None:
- raise AppUnavailableError()
- if app_model.mode != AppMode.COMPLETION:
+ @console_account_admission()
+ @get_installed_app
+ def post(
+ self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str
+ ) -> tuple[dict[str, object], int]:
+ try:
+ app_mode = application_services().app_definitions.get_mode(installed_app.app_id)
+ except AppDefinitionUnavailableError:
+ raise AppUnavailableError() from None
+ if app_mode != AppMode.COMPLETION:
raise NotCompletionAppError()
AppTaskService.stop_task(
task_id=task_id,
invoke_from=InvokeFrom.EXPLORE,
- user_id=current_user_id,
- app_mode=AppMode.value_of(app_model.mode),
+ user_id=request_context.account_id,
+ app_mode=AppMode.value_of(app_mode),
)
return SimpleResultResponse(result="success").model_dump(mode="json"), 200
@@ -244,22 +254,25 @@ class ChatApi(InstalledAppResource):
"/installed-apps/<uuid:installed_app_id>/chat-messages/<string:task_id>/stop",
endpoint="installed_app_stop_chat_completion",
)
-class ChatStopApi(InstalledAppResource):
+class ChatStopApi(Resource):
@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
- @with_current_user_id
- @with_session(write=False)
- def post(self, session: Session, current_user_id: str, installed_app: InstalledApp, task_id: str):
- app_model = installed_app.app_with_session(session=session)
- if app_model is None:
- raise AppUnavailableError()
- app_mode = AppMode.value_of(app_model.mode)
+ @console_account_admission()
+ @get_installed_app
+ def post(
+ self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str
+ ) -> tuple[dict[str, object], int]:
+ try:
+ mode = application_services().app_definitions.get_mode(installed_app.app_id)
+ except AppDefinitionUnavailableError:
+ raise AppUnavailableError() from None
+ app_mode = AppMode.value_of(mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
raise NotChatAppError()
AppTaskService.stop_task(
task_id=task_id,
invoke_from=InvokeFrom.EXPLORE,
- user_id=current_user_id,
+ user_id=request_context.account_id,
app_mode=app_mode,
)
diff --git a/api/tests/unit_tests/controllers/console/explore/test_completion.py b/api/tests/unit_tests/controllers/console/explore/test_completion.py
index a3a307ae264..15358a3cf23 100644
--- a/api/tests/unit_tests/controllers/console/explore/test_completion.py
+++ b/api/tests/unit_tests/controllers/console/explore/test_completion.py
@@ -305,27 +305,6 @@ class TestCompletionApi:
)
-class TestCompletionStopApi:
- def test_stop_success(self, completion_app):
- api = completion_module.CompletionStopApi()
- method = unwrap(api.post)
-
- with patch.object(completion_module.AppTaskService, "stop_task"):
- resp, status = method(api, _session(completion_app), "u1", completion_app, "task-1")
-
- assert status == 200
- assert resp == {"result": "success"}
-
- def test_stop_wrong_app_mode(self, sqlite_session: Session):
- api = completion_module.CompletionStopApi()
- method = unwrap(api.post)
-
- installed_app = _installed_app(AppMode.CHAT, sqlite_session)
-
- with pytest.raises(NotCompletionAppError):
- method(api, sqlite_session, "u1", installed_app, "task")
-
-
class TestChatApi:
def test_post_success(self, app: Flask, chat_app, user, payload_patch, payload_data):
api = completion_module.ChatApi()
@@ -612,23 +591,3 @@ class TestChatApi:
user,
chat_app,
)
-
-
-class TestChatStopApi:
- def test_stop_success(self, chat_app):
- api = completion_module.ChatStopApi()
- method = unwrap(api.post)
- with patch.object(completion_module.AppTaskService, "stop_task"):
- resp, status = method(api, _session(chat_app), "u1", chat_app, "task-1")
-
- assert status == 200
- assert resp == {"result": "success"}
-
- def test_stop_not_chat_app(self, sqlite_session: Session):
- api = completion_module.ChatStopApi()
- method = unwrap(api.post)
-
- installed_app = _installed_app(AppMode.COMPLETION, sqlite_session)
-
- with pytest.raises(NotChatAppError):
- method(api, sqlite_session, "u1", installed_app, "task")
diff --git a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py
index 333c06a40f0..3200901e01e 100644
--- a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py
+++ b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py
@@ -1,22 +1,28 @@
-from collections.abc import Callable
+import json
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
from dataclasses import dataclass, field
from operator import itemgetter
from uuid import UUID, uuid4
import pytest
-from flask import Flask, Request
+from flask import Flask, Request, got_request_exception
from flask_restx import Resource
+from redis.exceptions import ConnectionError as RedisConnectionError
from sqlalchemy import Connection, event, inspect
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.exceptions import Unauthorized
from werkzeug.test import TestResponse
+import controllers.console.explore.completion as completion_module
import controllers.console.explore.installed_app_admission as admission_module
import controllers.console.explore.parameter as parameter_module
import controllers.console.explore.saved_message as saved_message_module
import controllers.console.flask_admission as console_admission
import controllers.console.wraps as console_wraps
+import core.app.apps.base_app_queue_manager as app_queue_module
import libs.login as login_module
+import services.app_task_service as app_task_module
from controllers.console.explore.installed_app_admission import get_installed_app
from controllers.console.flask_admission import console_account_admission
from enums import DeploymentEdition
@@ -25,7 +31,9 @@ from libs.external_api import ExternalApi
from machinery.context import RequestContext
from models import Account, App, AppMode, InstalledApp, Tenant
from models.account import AccountStatus
+from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository
+from services.app_definition_query_service import AppDefinitionQueryService
from services.installed_app_access_service import InstalledAppAccessService, InstalledAppRef
from services.saved_message_service import SavedMessageActor, SavedMessagePage, SavedMessageRecord, SavedMessageService
from services.webapp_access_query_service import WebAppAccessUnavailableError
@@ -36,6 +44,7 @@ class _AdmissionState:
setup_completed: bool = True
allowed: bool = True
permission_error: Exception | None = None
+ permission_action: Callable[[], None] | None = None
events: list[str] = field(default_factory=list)
permission_calls: list[tuple[str, str]] = field(default_factory=list)
@@ -109,6 +118,8 @@ def harness(
assert all(not session.in_transaction() and not session.identity_map for session in repository_sessions)
if state.permission_error is not None:
raise state.permission_error
+ if state.permission_action is not None:
+ state.permission_action()
return state.allowed
services = _ApplicationServices(
@@ -495,3 +506,230 @@ def test_migrated_saved_message_and_parameter_handlers_dispatch_through_full_adm
body={"tool_icons": {"search": "/tools/search/icon"}},
)
assert harness.state.permission_calls == [(harness.account.id, harness.target_app.id)] * 5
+
+
+@dataclass
+class _StopRedis:
+ values: dict[str, bytes] = field(default_factory=dict)
+ commands: dict[str, list[str]] = field(default_factory=dict)
+ expirations: dict[str, int] = field(default_factory=dict)
+ reads: list[str] = field(default_factory=list)
+ read_error: Exception | None = None
+
+ def get(self, key: str) -> bytes | None:
+ self.reads.append(key)
+ if self.read_error is not None:
+ raise self.read_error
+ return self.values.get(key)
+
+ def setex(self, key: str, ttl: int, value: int) -> None:
+ self.values[key] = str(value).encode()
+ self.expirations[key] = ttl
+
+ @contextmanager
+ def pipeline(self) -> Generator["_StopRedis"]:
+ yield self
+
+ def rpush(self, key: str, value: str) -> int:
+ values = self.commands.setdefault(key, [])
+ values.append(value)
+ return len(values)
+
+ def expire(self, key: str, ttl: int) -> bool:
+ self.expirations[key] = ttl
+ return True
+
+ def set(self, key: str, value: str, *, ex: int) -> bool:
+ self.values[key] = value.encode()
+ self.expirations[key] = ex
+ return True
+
+ def execute(self) -> list[object]:
+ return []
+
+
+@dataclass(frozen=True)
+class _StopServices:
+ app_definitions: AppDefinitionQueryService
+
+
+_TASK_ID = "task-with-non-uuid-id"
+
+
+def stop_redis(
+ harness: _Harness,
+ monkeypatch: pytest.MonkeyPatch,
+ sqlite_session_factory: sessionmaker[Session],
+) -> _StopRedis:
+ redis = _StopRedis(values={f"generate_task_belong:{_TASK_ID}": f"account-{harness.account.id}".encode()})
+ services = _StopServices(
+ app_definitions=AppDefinitionQueryService(
+ definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),
+ builtin_icon_url_prefix="/tools/icons",
+ )
+ )
+ monkeypatch.setattr(completion_module, "application_services", lambda: services)
+ monkeypatch.setattr(app_queue_module, "redis_client", redis)
+ monkeypatch.setattr(app_task_module, "redis_client", redis)
+ harness.api.add_resource(
+ completion_module.CompletionStopApi,
+ "/installed-apps/<uuid:installed_app_id>/completion-messages/<string:task_id>/stop",
+ )
+ harness.api.add_resource(
+ completion_module.ChatStopApi,
+ "/installed-apps/<uuid:installed_app_id>/chat-messages/<string:task_id>/stop",
+ )
+ return redis
+
+
+def _stop_url(harness: _Harness, message_kind: str) -> str:
+ return f"/installed-apps/{harness.installed_app.id}/{message_kind}-messages/{_TASK_ID}/stop"
+
+
+def _set_app_mode(harness: _Harness, session_factory: sessionmaker[Session], mode: AppMode) -> None:
+ with session_factory.begin() as session:
+ app = session.get(App, harness.target_app.id)
+ assert app is not None
+ app.mode = mode
+
+
+ ("message_kind", "mode"),
+ [
+ ("completion", AppMode.COMPLETION),
+ ("chat", AppMode.CHAT),
+ ("chat", AppMode.AGENT_CHAT),
+ ("chat", AppMode.ADVANCED_CHAT),
+ ],
+)
+def test_stop_handlers_preserve_mode_specific_commands_and_response(
+ harness: _Harness,
+ stop_redis: _StopRedis,
+ sqlite_session_factory: sessionmaker[Session],
+ message_kind: str,
+ mode: AppMode,
+) -> None:
+ _set_app_mode(harness, sqlite_session_factory, mode)
+
+ response = harness.app.test_client().post(_stop_url(harness, message_kind))
+
+ _assert_json_response(response, status=200, body={"result": "success"})
+ assert stop_redis.reads == [f"generate_task_belong:{_TASK_ID}"]
+ assert stop_redis.values[f"generate_task_stopped:{_TASK_ID}"] == b"1"
+ assert stop_redis.expirations[f"generate_task_stopped:{_TASK_ID}"] == 600
+ if mode == AppMode.ADVANCED_CHAT:
+ command_key = f"workflow:{_TASK_ID}:commands"
+ assert set(stop_redis.commands) == {command_key}
+ assert [json.loads(command) for command in stop_redis.commands[command_key]] == [
+ {"command_type": "abort", "payload": None, "reason": "User requested stop"}
+ ]
+ else:
+ assert stop_redis.commands == {}
+ assert harness.state.permission_calls == [(harness.account.id, harness.target_app.id)]
+
+
+ ("message_kind", "mode", "code", "message"),
+ [
+ ("completion", AppMode.CHAT, "not_completion_app", "Not Completion App"),
+ ("chat", AppMode.COMPLETION, "not_chat_app", "App mode is invalid."),
+ ("chat", AppMode.WORKFLOW, "not_chat_app", "App mode is invalid."),
+ ],
+)
+def test_stop_handlers_reject_wrong_modes_without_sending_commands(
+ harness: _Harness,
+ stop_redis: _StopRedis,
+ sqlite_session_factory: sessionmaker[Session],
+ message_kind: str,
+ mode: AppMode,
+ code: str,
+ message: str,
+) -> None:
+ _set_app_mode(harness, sqlite_session_factory, mode)
+
+ response = harness.app.test_client().post(_stop_url(harness, message_kind))
+
+ _assert_json_response(response, status=400, body={"code": code, "message": message, "status": 400})
+ assert stop_redis.reads == []
+ assert stop_redis.commands == {}
+ assert f"generate_task_stopped:{_TASK_ID}" not in stop_redis.values
+
+
[email protected]("message_kind", ["completion", "chat"])
+def test_stop_handlers_reject_app_removed_after_admission_before_sending_commands(
+ harness: _Harness,
+ stop_redis: _StopRedis,
+ sqlite_session_factory: sessionmaker[Session],
+ message_kind: str,
+) -> None:
+ def remove_app() -> None:
+ with sqlite_session_factory.begin() as session:
+ app = session.get(App, harness.target_app.id)
+ assert app is not None
+ session.delete(app)
+
+ harness.state.permission_action = remove_app
+
+ response = harness.app.test_client().post(_stop_url(harness, message_kind))
+
+ _assert_json_response(
+ response,
+ status=400,
+ body={
+ "code": "app_unavailable",
+ "message": "App unavailable, please check your app configurations.",
+ "status": 400,
+ },
+ )
+ assert harness.state.permission_calls == [(harness.account.id, harness.target_app.id)]
+ assert stop_redis.reads == []
+ assert stop_redis.commands == {}
+
+
[email protected]("message_kind", ["completion", "chat"])
+def test_stop_handlers_enforce_admission_before_sending_commands(
+ harness: _Harness,
+ stop_redis: _StopRedis,
+ message_kind: str,
+) -> None:
+ harness.state.allowed = False
+
+ response = harness.app.test_client().post(_stop_url(harness, message_kind))
+
+ _assert_json_response(
+ response,
+ status=403,
+ body={"code": "access_denied", "message": "App access denied.", "status": 403},
+ )
+ assert stop_redis.reads == []
+ assert stop_redis.commands == {}
+
+
[email protected](("message_kind", "mode"), [("completion", AppMode.COMPLETION), ("chat", AppMode.CHAT)])
+def test_stop_handlers_propagate_redis_failure_to_existing_http_error_handler(
+ harness: _Harness,
+ stop_redis: _StopRedis,
+ sqlite_session_factory: sessionmaker[Session],
+ message_kind: str,
+ mode: AppMode,
+) -> None:
+ _set_app_mode(harness, sqlite_session_factory, mode)
+ failure = RedisConnectionError("Redis unavailable")
+ stop_redis.read_error = failure
+ exceptions: list[Exception] = []
+
+ def capture_exception(_sender: Flask, exception: Exception) -> None:
+ exceptions.append(exception)
+
+ with got_request_exception.connected_to(capture_exception):
+ response = harness.app.test_client().post(_stop_url(harness, message_kind))
+
+ _assert_json_response(
+ response,
+ status=500,
+ body={"code": "unknown", "message": "Internal Server Error", "status": 500},
+ )
+ assert any(exception is failure for exception in exceptions)
+ assert f"generate_task_stopped:{_TASK_ID}" not in stop_redis.values
+ assert stop_redis.commands == {}