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.

4.1 KB
Raw Blame
"""Adapt persisted endpoint snapshots to the plugin runtime and existing task queue."""

from flask import Request

from core.helper.provider_encryption import create_provider_encrypter
from core.plugin.impl.exc import PluginNotFoundError
from core.trigger.entities.entities import Subscription
from core.trigger.trigger_manager import TriggerManager
from core.trigger.utils.encryption import TriggerProviderCredentialsCache, TriggerProviderPropertiesCache
from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url
from models.provider_ids import TriggerProviderID
from services.trigger.endpoint_service import (
    TriggerEndpointDispatch,
    TriggerEndpointLoadError,
    TriggerEndpointProviderNotFoundError,
)
from services.trigger.subscription_service import TriggerSubscriptionSnapshot
from services.workflow.entities import PluginTriggerDispatchData


class PluginTriggerEndpointGateway:
    """Use existing credential caches after the subscription query has closed.

    TODO: The shared RSA key provider still owns a scoped DB session; remove that
    dependency when tenant key reads return detached values.
    """

    def dispatch(self, *, subscription: TriggerSubscriptionSnapshot, request: Request) -> TriggerEndpointDispatch:
        try:
            provider = TriggerManager.get_trigger_provider(
                tenant_id=subscription.tenant_id, provider_id=TriggerProviderID(subscription.provider_id)
            )
            credentials_encrypter, _ = create_provider_encrypter(
                tenant_id=subscription.tenant_id,
                config=provider.get_credential_schema_config(subscription.credential_type),
                cache=TriggerProviderCredentialsCache(
                    tenant_id=subscription.tenant_id,
                    provider_id=str(provider.get_provider_id()),
                    credential_id=subscription.id,
                ),
            )
            credentials = credentials_encrypter.decrypt(subscription.credentials)
            properties_encrypter, _ = create_provider_encrypter(
                tenant_id=subscription.tenant_id,
                config=provider.get_properties_schema(),
                cache=TriggerProviderPropertiesCache(
                    tenant_id=subscription.tenant_id,
                    provider_id=str(provider.get_provider_id()),
                    subscription_id=subscription.id,
                ),
            )
            properties = properties_encrypter.decrypt(subscription.properties)
        except Exception as error:
            # TriggerManager wraps a missing plugin in ValueError, preserving its cause.
            if isinstance(error, PluginNotFoundError) or (
                isinstance(error, ValueError) and isinstance(error.__cause__, PluginNotFoundError)
            ):
                raise TriggerEndpointProviderNotFoundError(
                    f"Trigger provider {subscription.provider_id} not found."
                ) from error
            raise TriggerEndpointLoadError(f"Failed to prepare trigger subscription {subscription.id}.") from error

        try:
            result = provider.dispatch(
                request=request,
                subscription=Subscription(
                    expires_at=subscription.expires_at,
                    endpoint=generate_plugin_trigger_endpoint_url(subscription.endpoint_id),
                    parameters=subscription.parameters,
                    properties=properties,
                ),
                credentials=credentials,
                credential_type=subscription.credential_type,
            )
        except PluginNotFoundError as error:
            raise TriggerEndpointProviderNotFoundError(
                f"Trigger provider {subscription.provider_id} not found."
            ) from error
        return TriggerEndpointDispatch(
            result=result, event_names=frozenset(event.identity.name for event in provider.get_events())
        )


def enqueue_triggered_workflows(data: PluginTriggerDispatchData) -> None:
    from tasks.trigger_processing_tasks import dispatch_triggered_workflows_async

    dispatch_triggered_workflows_async.delay(data.model_dump(mode="json"))