chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
60158935f4
commit
6519682885
15831 files changed
+3063428
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Domain-specific dependency composition for application services."""
|
||||
@@ -0,0 +1,360 @@
|
||||
"""Compose the account domain using shared account and workspace persistence."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
from functools import partial
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from constants.languages import languages
|
||||
from enums import DeploymentEdition
|
||||
from extensions.ext_redis import RedisClientWrapper
|
||||
from libs.datetime_utils import naive_utc_now, utc_now
|
||||
from libs.helper import RateLimiter
|
||||
from libs.oauth import GitHubOAuth, GoogleOAuth
|
||||
from libs.oauth_bearer import invalidate_oauth_token_cache
|
||||
from repositories.account.repository import SQLAlchemyAccountRepository
|
||||
from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
|
||||
from repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository
|
||||
from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepository
|
||||
from repositories.workspace.workspace_repository import WorkspaceRepository
|
||||
from services.account.adapters import (
|
||||
AccountIdentityGateway,
|
||||
BillingAccountActivationEligibility,
|
||||
BillingAccountDeletionFeedbackGateway,
|
||||
BillingAccountEducationGateway,
|
||||
BillingAccountEmailPolicyGateway,
|
||||
BillingWorkspaceMembershipCache,
|
||||
CeleryAccountDeletionScheduler,
|
||||
CeleryAccountDeletionVerificationNotifier,
|
||||
CeleryChangeEmailNotificationGateway,
|
||||
DeploymentAccountLifecyclePolicy,
|
||||
DeploymentWorkspaceInvitePolicy,
|
||||
EnterpriseAccountDeletionSyncGateway,
|
||||
RateLimiterChangeEmailSendLimiter,
|
||||
RBACWorkspaceMemberAccessSync,
|
||||
RedisChangeEmailSecurityGateway,
|
||||
RedisInvitationTokenStore,
|
||||
SecureChangeEmailCodeGenerator,
|
||||
TokenManagerAccountDeletionVerificationGateway,
|
||||
TokenManagerChangeEmailTokenGateway,
|
||||
)
|
||||
from services.account.email_registration_adapters import (
|
||||
AccountLifecycleRegistrationGateway,
|
||||
BillingAccountRegistrationPolicyGateway,
|
||||
CeleryEmailRegistrationNotificationGateway,
|
||||
RateLimiterEmailRegistrationSendLimiter,
|
||||
RedisEmailRegistrationSecurityGateway,
|
||||
SecureEmailRegistrationCodeGenerator,
|
||||
TokenManagerEmailRegistrationTokenGateway,
|
||||
)
|
||||
from services.account.email_registration_service import AccountEmailRegistrationService
|
||||
from services.account.forgot_password_adapters import (
|
||||
CeleryForgotPasswordNotificationGateway,
|
||||
RateLimiterForgotPasswordSendLimiter,
|
||||
RedisForgotPasswordSecurityGateway,
|
||||
RedisForgotPasswordTokenGateway,
|
||||
SecureForgotPasswordCodeGenerator,
|
||||
SystemFeatureServiceForgotPasswordRegistrationPolicy,
|
||||
)
|
||||
from services.account.forgot_password_service import AccountForgotPasswordService
|
||||
from services.account.login_adapters import (
|
||||
AccountActivationConsoleAuthInvitationGateway,
|
||||
DeploymentConsoleAuthPolicyGateway,
|
||||
LoggingConsoleAuthAuditGateway,
|
||||
RedisAccountSessionGateway,
|
||||
RedisConsoleAuthSecurityGateway,
|
||||
RedisEmailCodeGateway,
|
||||
RedisResetPasswordEmailGateway,
|
||||
SQLAlchemyAccountRefreshPreparationGateway,
|
||||
TurnstileHumanVerificationGateway,
|
||||
)
|
||||
from services.account.login_service import ConsoleAuthenticationService
|
||||
from services.account.oauth_adapters import (
|
||||
AccountActivationOAuthInvitationGateway,
|
||||
AccountLifecycleOAuthRegistrationGateway,
|
||||
AccountLifecycleOAuthSessionGateway,
|
||||
DeploymentOAuthPolicyGateway,
|
||||
DifyOAuthProviderGateway,
|
||||
RedisOAuthAccountClaimLock,
|
||||
WorkspaceProvisioningOAuthGateway,
|
||||
)
|
||||
from services.account.oauth_service import AccountOAuthService, OAuthProviderGateway
|
||||
from services.account.service import AccountService
|
||||
from services.account_access_service import AccountAccessService
|
||||
from services.account_activation_service import (
|
||||
AccountActivationRepository,
|
||||
AccountActivationService,
|
||||
InvitationTokenStore,
|
||||
)
|
||||
from services.account_avatar_file_gateway import SQLAlchemyAccountAvatarFileGateway
|
||||
from services.account_avatar_service import AccountAvatarService
|
||||
from services.account_change_email_service import AccountChangeEmailService
|
||||
from services.account_deletion_feedback_service import AccountDeletionFeedbackService
|
||||
from services.account_deletion_service import AccountDeletionService
|
||||
from services.account_education_service import AccountEducationService
|
||||
from services.account_initialization_service import AccountInitializationService
|
||||
from services.account_integration_service import AccountIntegrationService
|
||||
from services.account_password_hasher import DefaultAccountPasswordHasher
|
||||
from services.account_password_service import AccountPasswordService
|
||||
from services.account_profile_service import AccountProfileService
|
||||
from services.workspace.provisioning_service import WorkspaceProvisioningService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AccountServices:
|
||||
access: AccountAccessService
|
||||
activation: AccountActivationService
|
||||
authentication: ConsoleAuthenticationService
|
||||
avatar: AccountAvatarService
|
||||
change_email: AccountChangeEmailService
|
||||
email_registration: AccountEmailRegistrationService
|
||||
deletion: AccountDeletionService
|
||||
deletion_feedback: AccountDeletionFeedbackService
|
||||
education: AccountEducationService
|
||||
forgot_password: AccountForgotPasswordService
|
||||
initialization: AccountInitializationService
|
||||
integrations: AccountIntegrationService
|
||||
oauth: AccountOAuthService
|
||||
password: AccountPasswordService
|
||||
profile: AccountProfileService
|
||||
lifecycle: AccountService
|
||||
identity: AccountIdentityGateway
|
||||
|
||||
|
||||
def _build_account_oauth_service(
|
||||
*,
|
||||
deployment_edition: DeploymentEdition,
|
||||
redis: RedisClientWrapper,
|
||||
accounts: SQLAlchemyAccountRepository,
|
||||
integrations: SQLAlchemyAccountIntegrationRepository,
|
||||
memberships: WorkspaceRepository,
|
||||
lifecycle: AccountService,
|
||||
workspace_provisioning: WorkspaceProvisioningService,
|
||||
invitation_tokens: InvitationTokenStore,
|
||||
activation_accounts: AccountActivationRepository,
|
||||
) -> AccountOAuthService:
|
||||
providers: dict[str, OAuthProviderGateway] = {}
|
||||
if dify_config.GITHUB_CLIENT_ID and dify_config.GITHUB_CLIENT_SECRET:
|
||||
providers["github"] = DifyOAuthProviderGateway(
|
||||
provider_name="github",
|
||||
client=GitHubOAuth(
|
||||
client_id=dify_config.GITHUB_CLIENT_ID,
|
||||
client_secret=dify_config.GITHUB_CLIENT_SECRET,
|
||||
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/github",
|
||||
),
|
||||
)
|
||||
if dify_config.GOOGLE_CLIENT_ID and dify_config.GOOGLE_CLIENT_SECRET:
|
||||
providers["google"] = DifyOAuthProviderGateway(
|
||||
provider_name="google",
|
||||
client=GoogleOAuth(
|
||||
client_id=dify_config.GOOGLE_CLIENT_ID,
|
||||
client_secret=dify_config.GOOGLE_CLIENT_SECRET,
|
||||
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/google",
|
||||
),
|
||||
)
|
||||
|
||||
policy = DeploymentOAuthPolicyGateway(
|
||||
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
)
|
||||
return AccountOAuthService(
|
||||
providers=providers,
|
||||
accounts=accounts,
|
||||
integrations=integrations,
|
||||
memberships=memberships,
|
||||
invitations=AccountActivationOAuthInvitationGateway(tokens=invitation_tokens, accounts=activation_accounts),
|
||||
account_claims=RedisOAuthAccountClaimLock(client=redis),
|
||||
registration=AccountLifecycleOAuthRegistrationGateway(accounts=lifecycle),
|
||||
workspaces=WorkspaceProvisioningOAuthGateway(workspaces=workspace_provisioning),
|
||||
sessions=AccountLifecycleOAuthSessionGateway(accounts=lifecycle),
|
||||
registration_policy=policy,
|
||||
workspace_policy=policy,
|
||||
supported_languages=languages,
|
||||
now=naive_utc_now,
|
||||
)
|
||||
|
||||
|
||||
def build_account_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
deployment_edition: DeploymentEdition,
|
||||
redis: RedisClientWrapper,
|
||||
accounts: SQLAlchemyAccountRepository,
|
||||
integrations: SQLAlchemyAccountIntegrationRepository,
|
||||
workspace_repository: WorkspaceRepository,
|
||||
workspace_provisioning: WorkspaceProvisioningService,
|
||||
passwords: DefaultAccountPasswordHasher,
|
||||
invitation_tokens: RedisInvitationTokenStore,
|
||||
activation_accounts: SQLAlchemyAccountActivationRepository,
|
||||
) -> AccountServices:
|
||||
lifecycle = AccountService(
|
||||
security=RedisConsoleAuthSecurityGateway(redis=redis),
|
||||
accounts=accounts,
|
||||
policies=DeploymentAccountLifecyclePolicy(),
|
||||
passwords=passwords,
|
||||
workspaces=workspace_provisioning,
|
||||
sessions=RedisAccountSessionGateway(redis=redis),
|
||||
now=naive_utc_now,
|
||||
)
|
||||
activation = AccountActivationService(
|
||||
tokens=invitation_tokens,
|
||||
accounts=activation_accounts,
|
||||
workspace_policy=DeploymentWorkspaceInvitePolicy(),
|
||||
eligibility=BillingAccountActivationEligibility(
|
||||
enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
),
|
||||
membership_cache=BillingWorkspaceMembershipCache(
|
||||
enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
),
|
||||
member_access_sync=RBACWorkspaceMemberAccessSync(
|
||||
enabled=dify_config.RBAC_ENABLED,
|
||||
),
|
||||
)
|
||||
return AccountServices(
|
||||
lifecycle=lifecycle,
|
||||
activation=activation,
|
||||
identity=AccountIdentityGateway(accounts=accounts, redis=redis),
|
||||
access=AccountAccessService(
|
||||
accounts=accounts,
|
||||
workspaces=workspace_repository,
|
||||
sessions=SQLAlchemyOAuthAccessTokenRepository(session_factory=database_client),
|
||||
invalidate_token_cache=partial(invalidate_oauth_token_cache, redis),
|
||||
now=utc_now,
|
||||
),
|
||||
authentication=ConsoleAuthenticationService(
|
||||
accounts=accounts,
|
||||
workspaces=workspace_repository,
|
||||
invitations=AccountActivationConsoleAuthInvitationGateway(
|
||||
tokens=invitation_tokens,
|
||||
accounts=activation_accounts,
|
||||
activation=activation,
|
||||
),
|
||||
policies=DeploymentConsoleAuthPolicyGateway(
|
||||
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
),
|
||||
security=RedisConsoleAuthSecurityGateway(redis=redis),
|
||||
passwords=passwords,
|
||||
human_verification=TurnstileHumanVerificationGateway(),
|
||||
sessions=RedisAccountSessionGateway(redis=redis),
|
||||
refresh_preparation=SQLAlchemyAccountRefreshPreparationGateway(accounts=accounts),
|
||||
account_provisioning=workspace_provisioning,
|
||||
workspace_provisioning=workspace_provisioning,
|
||||
email_codes=RedisEmailCodeGateway(redis=redis),
|
||||
reset_password_emails=RedisResetPasswordEmailGateway(redis=redis),
|
||||
audit=LoggingConsoleAuthAuditGateway(),
|
||||
now=naive_utc_now,
|
||||
turnstile_enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
turnstile_verify_required=(
|
||||
deployment_edition == DeploymentEdition.CLOUD and dify_config.TURNSTILE_EMAIL_CODE_VERIFY_REQUIRED
|
||||
),
|
||||
),
|
||||
avatar=AccountAvatarService(
|
||||
files=SQLAlchemyAccountAvatarFileGateway(session_factory=database_client),
|
||||
),
|
||||
change_email=AccountChangeEmailService(
|
||||
accounts=accounts,
|
||||
tokens=TokenManagerChangeEmailTokenGateway(),
|
||||
codes=SecureChangeEmailCodeGenerator(),
|
||||
notifications=CeleryChangeEmailNotificationGateway(),
|
||||
send_limits=RateLimiterChangeEmailSendLimiter(redis=redis),
|
||||
security=RedisChangeEmailSecurityGateway(
|
||||
redis=redis,
|
||||
email_send_ip_limit_per_minute=dify_config.EMAIL_SEND_IP_LIMIT_PER_MINUTE,
|
||||
verification_failure_limit=5,
|
||||
verification_lockout_duration=dify_config.CHANGE_EMAIL_LOCKOUT_DURATION,
|
||||
),
|
||||
email_policy=BillingAccountEmailPolicyGateway(
|
||||
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
),
|
||||
),
|
||||
email_registration=AccountEmailRegistrationService(
|
||||
accounts=accounts,
|
||||
tokens=TokenManagerEmailRegistrationTokenGateway(),
|
||||
codes=SecureEmailRegistrationCodeGenerator(),
|
||||
notifications=CeleryEmailRegistrationNotificationGateway(),
|
||||
send_limits=RateLimiterEmailRegistrationSendLimiter(
|
||||
rate_limiter=RateLimiter(
|
||||
prefix="email_register_rate_limit",
|
||||
max_attempts=1,
|
||||
time_window=60,
|
||||
redis_client=redis,
|
||||
)
|
||||
),
|
||||
security=RedisEmailRegistrationSecurityGateway(
|
||||
redis=redis,
|
||||
login_security=RedisConsoleAuthSecurityGateway(redis=redis),
|
||||
verification_failure_limit=5,
|
||||
verification_lockout_duration=dify_config.EMAIL_REGISTER_LOCKOUT_DURATION,
|
||||
),
|
||||
account_policy=BillingAccountRegistrationPolicyGateway(
|
||||
enabled=deployment_edition == DeploymentEdition.CLOUD,
|
||||
),
|
||||
registration=AccountLifecycleRegistrationGateway(accounts=lifecycle),
|
||||
),
|
||||
deletion=AccountDeletionService(
|
||||
accounts=accounts,
|
||||
memberships=workspace_repository,
|
||||
verification=TokenManagerAccountDeletionVerificationGateway(),
|
||||
notifications=CeleryAccountDeletionVerificationNotifier(redis=redis),
|
||||
synchronization=EnterpriseAccountDeletionSyncGateway(),
|
||||
scheduler=CeleryAccountDeletionScheduler(),
|
||||
),
|
||||
deletion_feedback=AccountDeletionFeedbackService(
|
||||
feedback=BillingAccountDeletionFeedbackGateway(),
|
||||
),
|
||||
education=AccountEducationService(
|
||||
accounts=accounts,
|
||||
education=BillingAccountEducationGateway(),
|
||||
verification_rate_limiter=RateLimiter(
|
||||
prefix="edu_verification_rate_limit",
|
||||
max_attempts=10,
|
||||
time_window=60,
|
||||
redis_client=redis,
|
||||
),
|
||||
activation_rate_limiter=RateLimiter(
|
||||
prefix="edu_activation_rate_limit",
|
||||
max_attempts=10,
|
||||
time_window=60,
|
||||
redis_client=redis,
|
||||
),
|
||||
),
|
||||
forgot_password=AccountForgotPasswordService(
|
||||
accounts=accounts,
|
||||
passwords=passwords,
|
||||
tokens=RedisForgotPasswordTokenGateway(
|
||||
redis=redis,
|
||||
expiry_seconds=dify_config.RESET_PASSWORD_TOKEN_EXPIRY_MINUTES * 60,
|
||||
),
|
||||
codes=SecureForgotPasswordCodeGenerator(),
|
||||
notifications=CeleryForgotPasswordNotificationGateway(),
|
||||
send_limits=RateLimiterForgotPasswordSendLimiter(redis=redis),
|
||||
security=RedisForgotPasswordSecurityGateway(
|
||||
redis=redis,
|
||||
email_send_ip_limit_per_minute=dify_config.EMAIL_SEND_IP_LIMIT_PER_MINUTE,
|
||||
verification_lockout_duration=dify_config.FORGOT_PASSWORD_LOCKOUT_DURATION,
|
||||
),
|
||||
registration=SystemFeatureServiceForgotPasswordRegistrationPolicy(),
|
||||
),
|
||||
initialization=AccountInitializationService(
|
||||
accounts=accounts,
|
||||
invitation_required=deployment_edition == DeploymentEdition.CLOUD,
|
||||
now=naive_utc_now,
|
||||
),
|
||||
integrations=AccountIntegrationService(integrations=integrations),
|
||||
oauth=_build_account_oauth_service(
|
||||
deployment_edition=deployment_edition,
|
||||
redis=redis,
|
||||
accounts=accounts,
|
||||
integrations=integrations,
|
||||
memberships=workspace_repository,
|
||||
lifecycle=lifecycle,
|
||||
workspace_provisioning=workspace_provisioning,
|
||||
invitation_tokens=invitation_tokens,
|
||||
activation_accounts=activation_accounts,
|
||||
),
|
||||
password=AccountPasswordService(
|
||||
accounts=accounts,
|
||||
passwords=passwords,
|
||||
),
|
||||
profile=AccountProfileService(accounts=accounts),
|
||||
)
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Composition of the Agent App console use cases."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from repositories.app.agent_app_repository import AgentAppRepository
|
||||
from repositories.app.agent_sandbox_repository import AgentSandboxRepository
|
||||
from services.app.agent_app_feature_gateway import AgentAppFeatureValidator
|
||||
from services.app.agent_app_sandbox_service import AgentAppSandboxService
|
||||
from services.app.agent_app_service import AgentAppAccessService, AgentAppFeatureConfigService
|
||||
from services.app.agent_sandbox_file_gateway import AgentSandboxFileGateway, create_sandbox_client
|
||||
from services.file_request_service import FileRequestService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AgentAppServices:
|
||||
access: AgentAppAccessService
|
||||
features: AgentAppFeatureConfigService
|
||||
sandbox: AgentAppSandboxService
|
||||
|
||||
|
||||
def build_agent_app_services(*, database_client: sessionmaker[Session]) -> AgentAppServices:
|
||||
apps = AgentAppRepository(session_factory=database_client)
|
||||
return AgentAppServices(
|
||||
access=AgentAppAccessService(references=apps),
|
||||
features=AgentAppFeatureConfigService(features=apps, validator=AgentAppFeatureValidator()),
|
||||
sandbox=AgentAppSandboxService(
|
||||
bindings=AgentSandboxRepository(session_factory=database_client, apps=apps),
|
||||
files=AgentSandboxFileGateway(
|
||||
client_factory=create_sandbox_client,
|
||||
file_requests=FileRequestService(),
|
||||
files_url=dify_config.FILES_URL,
|
||||
),
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,104 @@
|
||||
"""Composition of App use cases."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from libs.datetime_utils import naive_utc_now
|
||||
from repositories.account.repository import SQLAlchemyAccountRepository
|
||||
from repositories.app.api_key_repository import AppApiKeyRepository
|
||||
from repositories.app.console_repository import ConsoleAppRepository
|
||||
from repositories.app.dsl_import_repository import DslImportRepository
|
||||
from repositories.app.enterprise_app_repository import EnterpriseAppRepository
|
||||
from repositories.app.export_repository import AppExportRepository
|
||||
from repositories.factory import DifyAPIRepositoryFactory
|
||||
from repositories.trigger.app_repository import SQLAlchemyAppTriggerRepository
|
||||
from repositories.workspace.workspace_repository import WorkspaceRepository
|
||||
from services.agent.roster_package_exporter import RosterAgentPackageExporter
|
||||
from services.agent.roster_package_importer import RosterAgentPackageImporter
|
||||
from services.api_token_service import ApiTokenCache
|
||||
from services.app.api_key_service import AppApiKeyService
|
||||
from services.app.console_gateway import AppLifecycleGateway, AppTransferGateway, EnterpriseConsoleAppAccess
|
||||
from services.app.console_service import ConsoleAppService
|
||||
from services.app.creators_platform_gateway import CreatorsPlatformGateway
|
||||
from services.app.discovery_gateway import EnterpriseAppDiscoveryAccess
|
||||
from services.app.enterprise_app_service import EnterpriseAppService
|
||||
from services.app.export_service import AppExportService
|
||||
from services.app.import_service import AppImportService
|
||||
from services.app.query_service import AppDiscoveryService
|
||||
from services.app_dsl_service import AppDslService
|
||||
from services.app_package_service import AppPackageService
|
||||
from services.app_tracing_config_service import AppTracingConfigService
|
||||
from services.oauth_server_service import OAuthServerService
|
||||
from services.rbac.members import MemberService
|
||||
from services.recommended_app_package_service import RecommendedAppPackageService
|
||||
from services.trigger.app_trigger_store import AppTriggerStore
|
||||
from services.workflow.dsl_import import DslImportService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AppServices:
|
||||
imports: AppImportService
|
||||
exports: AppExportService
|
||||
dsl_imports: DslImportService
|
||||
discovery: AppDiscoveryService
|
||||
console: ConsoleAppService
|
||||
enterprise: EnterpriseAppService
|
||||
triggers: AppTriggerStore
|
||||
|
||||
|
||||
def build_app_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
oauth: OAuthServerService,
|
||||
recommended_packages: RecommendedAppPackageService,
|
||||
repository: ConsoleAppRepository,
|
||||
rbac_members: MemberService,
|
||||
tracing_configs: AppTracingConfigService,
|
||||
) -> AppServices:
|
||||
transfers = AppTransferGateway(
|
||||
session_factory=database_client,
|
||||
dsl_factory=AppDslService,
|
||||
packages=AppPackageService(),
|
||||
agent_packages=RosterAgentPackageExporter(),
|
||||
agent_importer=RosterAgentPackageImporter(),
|
||||
recommended_packages=recommended_packages,
|
||||
)
|
||||
return AppServices(
|
||||
imports=AppImportService(accounts=SQLAlchemyAccountRepository(database_client), definitions=transfers),
|
||||
exports=AppExportService(
|
||||
apps=AppExportRepository(session_factory=database_client), serialize=AppDslService.serialize_export_data
|
||||
),
|
||||
dsl_imports=DslImportService(store=DslImportRepository(session_factory=database_client)),
|
||||
discovery=AppDiscoveryService(
|
||||
apps=repository,
|
||||
workspaces=WorkspaceRepository(database_client),
|
||||
access=EnterpriseAppDiscoveryAccess(),
|
||||
),
|
||||
console=ConsoleAppService(
|
||||
apps=repository,
|
||||
access=EnterpriseConsoleAppAccess(members=rbac_members),
|
||||
transfers=transfers,
|
||||
creators=CreatorsPlatformGateway(oauth=oauth),
|
||||
tracing=tracing_configs,
|
||||
lifecycle=AppLifecycleGateway(session_factory=database_client),
|
||||
),
|
||||
enterprise=EnterpriseAppService(
|
||||
apps=EnterpriseAppRepository(
|
||||
session_factory=database_client,
|
||||
app_web_url=dify_config.APP_WEB_URL,
|
||||
service_api_url=dify_config.SERVICE_API_URL,
|
||||
),
|
||||
workflow_runs=DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker=database_client),
|
||||
now=naive_utc_now,
|
||||
),
|
||||
triggers=SQLAlchemyAppTriggerRepository(session_factory=database_client),
|
||||
)
|
||||
|
||||
|
||||
def build_app_api_key_service(*, database_client: sessionmaker[Session]) -> AppApiKeyService:
|
||||
return AppApiKeyService(
|
||||
keys=AppApiKeyRepository(session_factory=database_client),
|
||||
cache=ApiTokenCache,
|
||||
)
|
||||
@@ -0,0 +1,137 @@
|
||||
"""Composition root for data-source services and shared credential gateways."""
|
||||
|
||||
from collections.abc import Mapping
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from core.datasource.datasource_manager import DatasourceManager
|
||||
from core.helper.ssrf_proxy import ssrf_proxy
|
||||
from core.plugin.impl.datasource import PluginDatasourceManager
|
||||
from core.plugin.impl.oauth import OAuthHandler
|
||||
from extensions.ext_redis import redis_client
|
||||
from repositories.data_source.api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepository
|
||||
from repositories.data_source.credential_repository import SQLAlchemyDatasourceCredentialRepository
|
||||
from repositories.data_source.oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepository
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
|
||||
from services.credentials.redis_refresh_lock import RedisCredentialRefreshLock
|
||||
from services.data_source.auth.api_key_gateways import (
|
||||
ProviderApiKeyAuthCredentialValidator,
|
||||
TenantApiKeyAuthCredentialEncryptor,
|
||||
)
|
||||
from services.data_source.auth.api_key_service import DataSourceApiKeyAuthService
|
||||
from services.data_source.binding_application_service import DataSourceBindingApplicationService
|
||||
from services.data_source.credential_adapters import (
|
||||
OAuthDatasourceCredentialRefresher,
|
||||
PluginDatasourceCredentialCodec,
|
||||
PluginDatasourceOAuthClientResolver,
|
||||
)
|
||||
from services.data_source.credential_gateway import (
|
||||
ActorAwareDatasourceCredentialGateway,
|
||||
TrustedStoredDatasourceCredentialGateway,
|
||||
)
|
||||
from services.data_source.notion_import_adapters import PluginNotionSourceGateway
|
||||
from services.data_source.notion_import_application_service import NotionImportApplicationService
|
||||
from services.data_source.notion_oauth_gateway import NotionDataSourceGateway
|
||||
from services.data_source.oauth_service import DataSourceOAuthService, InvalidDataSourceOAuthProviderError
|
||||
from services.data_source.provider_service import DatasourceProviderService
|
||||
from services.data_source.website_service import WebsiteService
|
||||
from services.knowledge.dataset_access import DatasetAccessService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DataSourceServices:
|
||||
providers: DatasourceProviderService
|
||||
api_key_auth: DataSourceApiKeyAuthService
|
||||
oauth: Mapping[str, DataSourceOAuthService]
|
||||
bindings: DataSourceBindingApplicationService
|
||||
notion_imports: NotionImportApplicationService
|
||||
|
||||
def resolve_oauth(self, provider: str) -> DataSourceOAuthService:
|
||||
service = self.oauth.get(provider)
|
||||
if service is None:
|
||||
raise InvalidDataSourceOAuthProviderError("Invalid provider")
|
||||
return service
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DataSourceCredentials:
|
||||
providers: DatasourceProviderService
|
||||
actor: ActorAwareDatasourceCredentialGateway
|
||||
stored: TrustedStoredDatasourceCredentialGateway
|
||||
|
||||
|
||||
def build_data_source_credentials(*, database_client: sessionmaker[Session]) -> DataSourceCredentials:
|
||||
credentials = SQLAlchemyDatasourceCredentialRepository(session_factory=database_client)
|
||||
provider_manager = PluginDatasourceManager()
|
||||
codec = PluginDatasourceCredentialCodec(provider_manager=provider_manager)
|
||||
refresher = OAuthDatasourceCredentialRefresher(
|
||||
oauth_clients=PluginDatasourceOAuthClientResolver(configs=credentials, provider_manager=provider_manager),
|
||||
oauth_handler=OAuthHandler(),
|
||||
)
|
||||
refresh_lock = RedisCredentialRefreshLock(client=redis_client)
|
||||
return DataSourceCredentials(
|
||||
providers=DatasourceProviderService(
|
||||
credentials=credentials,
|
||||
codec=codec,
|
||||
refresher=refresher,
|
||||
refresh_lock=refresh_lock,
|
||||
provider_manager=provider_manager,
|
||||
),
|
||||
actor=ActorAwareDatasourceCredentialGateway(
|
||||
credentials=credentials, codec=codec, refresher=refresher, refresh_lock=refresh_lock
|
||||
),
|
||||
stored=TrustedStoredDatasourceCredentialGateway(
|
||||
credentials=credentials, codec=codec, refresher=refresher, refresh_lock=refresh_lock
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def build_data_source_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
dataset_access: DatasetAccessService,
|
||||
datasets: SQLAlchemyDatasetRepository,
|
||||
documents: SQLAlchemyDocumentRepository,
|
||||
actor_credentials: ActorAwareDatasourceCredentialGateway,
|
||||
providers: DatasourceProviderService,
|
||||
) -> DataSourceServices:
|
||||
oauth_bindings = SQLAlchemyDataSourceOAuthBindingRepository(session_factory=database_client)
|
||||
notion_gateway = NotionDataSourceGateway(
|
||||
client_id=dify_config.NOTION_CLIENT_ID or "",
|
||||
client_secret=dify_config.NOTION_CLIENT_SECRET or "",
|
||||
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/data-source/callback/notion",
|
||||
http_client=ssrf_proxy,
|
||||
)
|
||||
return DataSourceServices(
|
||||
providers=providers,
|
||||
api_key_auth=DataSourceApiKeyAuthService(
|
||||
bindings=SQLAlchemyDataSourceApiKeyAuthBindingRepository(session_factory=database_client),
|
||||
validator=ProviderApiKeyAuthCredentialValidator(),
|
||||
encryptor=TenantApiKeyAuthCredentialEncryptor(),
|
||||
),
|
||||
oauth={
|
||||
"notion": DataSourceOAuthService(
|
||||
provider_name="notion",
|
||||
provider_gateway=notion_gateway,
|
||||
bindings=oauth_bindings,
|
||||
is_internal_provider=dify_config.NOTION_INTEGRATION_TYPE == "internal",
|
||||
internal_access_token=dify_config.NOTION_INTERNAL_SECRET,
|
||||
)
|
||||
},
|
||||
bindings=DataSourceBindingApplicationService(bindings=oauth_bindings),
|
||||
notion_imports=NotionImportApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
datasets=datasets,
|
||||
documents=documents,
|
||||
source=PluginNotionSourceGateway(
|
||||
credentials=actor_credentials, runtime_loader=DatasourceManager.get_datasource_runtime
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def build_website_service(*, database_client: sessionmaker[Session]) -> WebsiteService:
|
||||
return WebsiteService(providers=build_data_source_credentials(database_client=database_client).providers)
|
||||
@@ -0,0 +1,32 @@
|
||||
"""Shared dataset dependencies for knowledge and data-source use cases."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
|
||||
from services.knowledge.dataset_access import DatasetAccessService, WorkspaceRoleReader
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DatasetDependencies:
|
||||
datasets: SQLAlchemyDatasetRepository
|
||||
documents: SQLAlchemyDocumentRepository
|
||||
access: DatasetAccessService
|
||||
|
||||
|
||||
def build_dataset_dependencies(
|
||||
*, database_client: sessionmaker[Session], workspace_roles: WorkspaceRoleReader
|
||||
) -> DatasetDependencies:
|
||||
datasets = SQLAlchemyDatasetRepository(session_factory=database_client)
|
||||
return DatasetDependencies(
|
||||
datasets=datasets,
|
||||
documents=SQLAlchemyDocumentRepository(session_factory=database_client),
|
||||
access=DatasetAccessService(
|
||||
datasets=datasets,
|
||||
workspace_roles=workspace_roles,
|
||||
legacy_permissions_enabled=not dify_config.RBAC_ENABLED,
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,60 @@
|
||||
"""Composition of Installed App use cases."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
|
||||
from services.conversation_command_service import ConversationCommandService
|
||||
from services.conversation_name_service import ConversationNameService
|
||||
from services.conversation_query_service import ConversationQueryService
|
||||
from services.installed_app_access_service import InstalledAppAccessService
|
||||
from services.installed_app_conversation_service import InstalledAppConversationService
|
||||
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
|
||||
from services.installed_app_generation_service import InstalledAppGenerationService
|
||||
from services.installed_app_service import InstalledAppService, WorkspaceRoleLookup
|
||||
from services.webapp_access_query_service import WebAppAccessQueryService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class InstalledAppServices:
|
||||
access: InstalledAppAccessService
|
||||
management: InstalledAppService
|
||||
generation: InstalledAppGenerationService
|
||||
conversations: InstalledAppConversationService
|
||||
|
||||
|
||||
def build_installed_app_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
conversation_queries: ConversationQueryService,
|
||||
conversation_names: ConversationNameService,
|
||||
conversation_commands: ConversationCommandService,
|
||||
webapp_access: WebAppAccessQueryService,
|
||||
get_workspace_role: WorkspaceRoleLookup,
|
||||
webapp_auth_enabled: bool,
|
||||
) -> InstalledAppServices:
|
||||
installed_apps = SQLAlchemyInstalledAppRepository(session_factory=database_client)
|
||||
access = InstalledAppAccessService(
|
||||
installed_apps=installed_apps,
|
||||
is_user_allowed=webapp_access.is_user_allowed,
|
||||
get_access_modes=webapp_access.batch_get_access_modes,
|
||||
get_user_permissions=webapp_access.batch_get_user_permissions,
|
||||
)
|
||||
return InstalledAppServices(
|
||||
access=access,
|
||||
management=InstalledAppService(
|
||||
installed_apps=installed_apps,
|
||||
get_workspace_role=get_workspace_role,
|
||||
get_visible_app_ids=access.get_visible_app_ids if webapp_auth_enabled else None,
|
||||
),
|
||||
generation=InstalledAppGenerationService(
|
||||
usage=installed_apps,
|
||||
runtime=AppGenerateServiceRuntime(session_factory=database_client),
|
||||
),
|
||||
conversations=InstalledAppConversationService(
|
||||
queries=conversation_queries,
|
||||
names=conversation_names,
|
||||
commands=conversation_commands,
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,195 @@
|
||||
"""Composition root for dataset-controller application services."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
from uuid import uuid4
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
|
||||
from core.rag.extractor.entity.datasource_type import DatasourceType
|
||||
from libs.helper import generate_text_hash
|
||||
from repositories.app.console_repository import ConsoleAppRepository
|
||||
from repositories.knowledge.dataset_api_key_repository import DatasetApiKeyRepository
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
|
||||
from repositories.knowledge.metadata_repository import SQLAlchemyMetadataRepository
|
||||
from repositories.knowledge.segment_repository import SQLAlchemySegmentRepository
|
||||
from repositories.knowledge.upload_file_repository import SQLAlchemyKnowledgeUploadRepository
|
||||
from services.api_token_service import ApiTokenCache, get_effective_token_last_used_at
|
||||
from services.data_source.credential_gateway import (
|
||||
ActorAwareDatasourceCredentialGateway,
|
||||
TrustedStoredDatasourceCredentialGateway,
|
||||
)
|
||||
from services.data_source.provider_service import DatasourceProviderService
|
||||
from services.knowledge.api_key_service import DatasetApiKeyService
|
||||
from services.knowledge.dataset_access import DatasetAccessService
|
||||
from services.knowledge.dataset_service import DocumentService
|
||||
from services.knowledge.datasets.adapters import SQLAlchemyDatasetOperations
|
||||
from services.knowledge.datasets.application import DatasetApplicationService
|
||||
from services.knowledge.datasets.upgrades import KnowledgeUpgradeApplicationService
|
||||
from services.knowledge.document_sync import DocumentSyncApplicationService
|
||||
from services.knowledge.document_sync_adapters import CeleryDocumentSyncDispatcher
|
||||
from services.knowledge.documents.adapters import SQLAlchemyDocumentOperations
|
||||
from services.knowledge.documents.application import DatasetDocumentApplicationService
|
||||
from services.knowledge.external.adapters import SQLAlchemyExternalKnowledgeOperations
|
||||
from services.knowledge.external.application import ExternalKnowledgeApplicationService
|
||||
from services.knowledge.indexing.adapters.estimate import IndexingEstimateAdapter, SQLAlchemyProcessRuleReader
|
||||
from services.knowledge.indexing.adapters.sources import (
|
||||
CompositeStoredSourceResolver,
|
||||
FileSourceAdapter,
|
||||
NotionSourceResolver,
|
||||
WebsiteSourceAdapter,
|
||||
)
|
||||
from services.knowledge.indexing.estimate import IndexingEstimateApplicationService
|
||||
from services.knowledge.metadata.application import MetadataService
|
||||
from services.knowledge.segments.adapters import (
|
||||
CelerySegmentBatchImportDispatcher,
|
||||
ModelManagerSegmentGuard,
|
||||
RedisSegmentClient,
|
||||
RedisSegmentIndexingState,
|
||||
)
|
||||
from services.knowledge.segments.application import DatasetSegmentApplicationService
|
||||
from services.knowledge.segments.indexing import SegmentIndexingGateway
|
||||
from services.knowledge_fs.feature_service import get_knowledge_fs_features
|
||||
from services.rbac.members import MemberService
|
||||
from services.tag_application_service import TagTargetQuery
|
||||
from services.workflow_run_agg import WorkflowRunAgg
|
||||
from tasks.batch_create_segment_to_index_task import batch_create_segment_to_index_task
|
||||
from tasks.delete_segment_from_index_task import delete_segment_from_index_task
|
||||
from tasks.disable_segments_from_index_task import disable_segments_from_index_task
|
||||
from tasks.document_indexing_sync_task import document_indexing_sync_task
|
||||
from tasks.enable_segments_to_index_task import enable_segments_to_index_task
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class KnowledgeServices:
|
||||
metadata: MetadataService
|
||||
datasets: DatasetApplicationService
|
||||
external: ExternalKnowledgeApplicationService
|
||||
documents: DatasetDocumentApplicationService
|
||||
document_sync: DocumentSyncApplicationService
|
||||
indexing_estimates: IndexingEstimateApplicationService
|
||||
segments: DatasetSegmentApplicationService
|
||||
pipeline_generator: PipelineGenerator
|
||||
upgrades: KnowledgeUpgradeApplicationService
|
||||
|
||||
|
||||
def build_dataset_api_key_service(
|
||||
*, database_client: sessionmaker[Session], dataset_access: DatasetAccessService
|
||||
) -> DatasetApiKeyService:
|
||||
return DatasetApiKeyService(
|
||||
keys=DatasetApiKeyRepository(session_factory=database_client),
|
||||
cache=ApiTokenCache,
|
||||
access=dataset_access,
|
||||
last_used_at=get_effective_token_last_used_at,
|
||||
rbac_enabled=lambda: dify_config.RBAC_ENABLED,
|
||||
)
|
||||
|
||||
|
||||
def build_knowledge_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
dataset_access: DatasetAccessService,
|
||||
datasets: SQLAlchemyDatasetRepository,
|
||||
documents: SQLAlchemyDocumentRepository,
|
||||
actor_credentials: ActorAwareDatasourceCredentialGateway,
|
||||
stored_credentials: TrustedStoredDatasourceCredentialGateway,
|
||||
providers: DatasourceProviderService,
|
||||
redis: RedisSegmentClient,
|
||||
tags: TagTargetQuery,
|
||||
rbac_members: MemberService,
|
||||
) -> KnowledgeServices:
|
||||
"""Build the dataset-controller knowledge use cases."""
|
||||
|
||||
uploads = SQLAlchemyKnowledgeUploadRepository(session_factory=database_client)
|
||||
notion_sources = NotionSourceResolver(
|
||||
actor_credentials=actor_credentials,
|
||||
stored_credentials=stored_credentials,
|
||||
)
|
||||
file_sources = FileSourceAdapter(uploads=uploads)
|
||||
website_sources = WebsiteSourceAdapter()
|
||||
stored_sources = CompositeStoredSourceResolver(
|
||||
adapters={
|
||||
DatasourceType.FILE.value: file_sources,
|
||||
DatasourceType.NOTION.value: notion_sources,
|
||||
DatasourceType.WEBSITE.value: website_sources,
|
||||
}
|
||||
)
|
||||
segments = SQLAlchemySegmentRepository(session_factory=database_client)
|
||||
segment_index = SegmentIndexingGateway(
|
||||
segments=segments,
|
||||
uploads=uploads,
|
||||
redis=redis,
|
||||
new_session=database_client,
|
||||
delete_task=delete_segment_from_index_task.delay,
|
||||
enable_task=enable_segments_to_index_task.delay,
|
||||
disable_task=disable_segments_from_index_task.delay,
|
||||
)
|
||||
dataset_operations = SQLAlchemyDatasetOperations(
|
||||
session_factory=database_client,
|
||||
tags=tags,
|
||||
app_queries=ConsoleAppRepository(session_factory=database_client),
|
||||
members=rbac_members,
|
||||
)
|
||||
return KnowledgeServices(
|
||||
metadata=MetadataService(
|
||||
store=SQLAlchemyMetadataRepository(session_factory=database_client), dataset_access=dataset_access
|
||||
),
|
||||
datasets=DatasetApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
operations=dataset_operations,
|
||||
rbac_enabled=dify_config.RBAC_ENABLED,
|
||||
service_api_url=dify_config.SERVICE_API_URL,
|
||||
vector_store=dify_config.VECTOR_STORE,
|
||||
tidb_fulltext=dify_config.TIDB_VECTOR_ENABLE_FULLTEXT_SEARCH,
|
||||
),
|
||||
external=ExternalKnowledgeApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
operations=SQLAlchemyExternalKnowledgeOperations(session_factory=database_client, members=rbac_members),
|
||||
),
|
||||
documents=DatasetDocumentApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
operations=SQLAlchemyDocumentOperations(session_factory=database_client),
|
||||
metadata_schema=DocumentService.DOCUMENT_METADATA_SCHEMA,
|
||||
),
|
||||
pipeline_generator=PipelineGenerator(
|
||||
execution_driver=WorkflowRunAgg.run, documents=documents, datasource_providers=providers
|
||||
),
|
||||
upgrades=KnowledgeUpgradeApplicationService(
|
||||
session_factory=database_client,
|
||||
dataset_access=dataset_access,
|
||||
datasets=dataset_operations,
|
||||
rbac_enabled=dify_config.RBAC_ENABLED,
|
||||
feature_enabled=lambda: get_knowledge_fs_features().enabled,
|
||||
),
|
||||
document_sync=DocumentSyncApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
documents=documents,
|
||||
dispatcher=CeleryDocumentSyncDispatcher(delay=document_indexing_sync_task.delay),
|
||||
),
|
||||
indexing_estimates=IndexingEstimateApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
datasets=datasets,
|
||||
documents=documents,
|
||||
files=file_sources,
|
||||
websites=website_sources,
|
||||
stored_sources=stored_sources,
|
||||
notion=notion_sources,
|
||||
process_rules=SQLAlchemyProcessRuleReader(session_factory=database_client),
|
||||
runner=IndexingEstimateAdapter(session_factory=database_client),
|
||||
),
|
||||
segments=DatasetSegmentApplicationService(
|
||||
dataset_access=dataset_access,
|
||||
scopes=datasets,
|
||||
store=segments,
|
||||
index=segment_index,
|
||||
limits=dify_config,
|
||||
text_hash=generate_text_hash,
|
||||
uploads=uploads,
|
||||
model_guard=ModelManagerSegmentGuard(),
|
||||
indexing_state=RedisSegmentIndexingState(redis),
|
||||
batch_dispatcher=CelerySegmentBatchImportDispatcher(delay=batch_create_segment_to_index_task.delay),
|
||||
job_id_factory=lambda: str(uuid4()),
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,71 @@
|
||||
"""Compose RBAC use cases with the existing workspace, app and dataset repositories."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from repositories.app.console_repository import ConsoleAppRepository
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.workspace.workspace_repository import WorkspaceRepository
|
||||
from services.enterprise import rbac_service as enterprise
|
||||
from services.rbac.gateways import (
|
||||
CeleryAccessInitializer,
|
||||
DeploymentRBACSettings,
|
||||
EnterpriseResourceAccessClients,
|
||||
)
|
||||
from services.rbac.members import MemberService
|
||||
from services.rbac.policies import PolicyService
|
||||
from services.rbac.resource_queries import ResourceQueryService
|
||||
from services.rbac.resources import ResourceAccessService
|
||||
from services.rbac.roles import RoleService
|
||||
from services.workspace.member_service import WorkspaceMemberService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RBACServices:
|
||||
roles: RoleService
|
||||
policies: PolicyService
|
||||
members: MemberService
|
||||
resources: ResourceAccessService
|
||||
queries: ResourceQueryService
|
||||
|
||||
|
||||
def build_rbac_services(
|
||||
*,
|
||||
workspaces: WorkspaceRepository,
|
||||
workspace_members: WorkspaceMemberService,
|
||||
apps: ConsoleAppRepository,
|
||||
datasets: SQLAlchemyDatasetRepository,
|
||||
) -> RBACServices:
|
||||
settings = DeploymentRBACSettings()
|
||||
return RBACServices(
|
||||
queries=ResourceQueryService(apps=apps, datasets=datasets),
|
||||
roles=RoleService(
|
||||
roles=enterprise.RBACService.KnowledgeFSRoles, catalog=enterprise.RBACService.Catalog, settings=settings
|
||||
),
|
||||
policies=PolicyService(
|
||||
policies=enterprise.RBACService.AccessPolicies, bindings=enterprise.RBACService.AccessPolicyBindings
|
||||
),
|
||||
members=MemberService(
|
||||
members=workspaces,
|
||||
workspace_roles=workspace_members,
|
||||
roles=enterprise.RBACService.KnowledgeFSMemberRoles,
|
||||
permissions=enterprise.RBACService.MyPermissions,
|
||||
apps=enterprise.RBACService.AppPermissions,
|
||||
datasets=enterprise.RBACService.DatasetPermissions,
|
||||
settings=settings,
|
||||
),
|
||||
resources=ResourceAccessService(
|
||||
clients=EnterpriseResourceAccessClients(
|
||||
apps=enterprise._APP_ACCESS,
|
||||
datasets=enterprise._DATASET_ACCESS,
|
||||
agents=enterprise._AGENT_ACCESS,
|
||||
workspace_apps=enterprise._WORKSPACE_APP_ACCESS,
|
||||
workspace_datasets=enterprise._WORKSPACE_DATASET_ACCESS,
|
||||
workspace_agents=enterprise._WORKSPACE_AGENT_ACCESS,
|
||||
catalogs=enterprise.RBACService.Catalog,
|
||||
),
|
||||
members=workspaces,
|
||||
apps=apps,
|
||||
datasets=datasets,
|
||||
initializer=CeleryAccessInitializer(),
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,18 @@
|
||||
"""Compose the resource access token service at the application boundary."""
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from repositories.resource_access_token_repository import (
|
||||
ResourceAccessTokenCleanupRepository,
|
||||
ResourceAccessTokenRepository,
|
||||
)
|
||||
from services.resource_access_token_service import ResourceAccessTokenCleanupService, ResourceAccessTokenService
|
||||
|
||||
|
||||
def build_resource_access_token_service(*, database_client: sessionmaker[Session]) -> ResourceAccessTokenService:
|
||||
return ResourceAccessTokenService(tokens=ResourceAccessTokenRepository(session_factory=database_client))
|
||||
|
||||
|
||||
def build_resource_access_token_cleanup_service(*, session: Session) -> ResourceAccessTokenCleanupService:
|
||||
"""Bind cleanup to an existing transaction without taking ownership of its lifetime."""
|
||||
return ResourceAccessTokenCleanupService(tokens=ResourceAccessTokenCleanupRepository(session=session))
|
||||
@@ -0,0 +1,35 @@
|
||||
"""Compose provider-scoped tool credential resolution for workflow execution."""
|
||||
|
||||
from collections.abc import Mapping
|
||||
|
||||
from configs import dify_config
|
||||
from core.db.session_factory import get_session_maker
|
||||
from core.plugin.entities.plugin_daemon import CredentialType
|
||||
from core.tools.builtin_tool.provider import BuiltinToolProviderController
|
||||
from core.tools.plugin_tool.provider import PluginToolProviderController
|
||||
from extensions.ext_redis import redis_client
|
||||
from models.provider_ids import ToolProviderID
|
||||
from repositories.credentials.query_repository import CredentialQueryRepository
|
||||
from services.credentials.redis_refresh_lock import RedisCredentialRefreshLock
|
||||
from services.credentials.tool_runtime import ToolCredentialService
|
||||
from services.credentials.tool_runtime_adapters import ProviderToolCredentialRuntime
|
||||
|
||||
|
||||
def resolve_tool_credentials(
|
||||
*, controller: BuiltinToolProviderController, provider_id: str, workspace_id: str, credential_id: str | None
|
||||
) -> tuple[Mapping[str, object], CredentialType]:
|
||||
if isinstance(controller, PluginToolProviderController):
|
||||
provider = ToolProviderID(provider_id)
|
||||
providers = (str(provider), provider.provider_name)
|
||||
else:
|
||||
providers = (provider_id,)
|
||||
runtime = ProviderToolCredentialRuntime(
|
||||
controller=controller, provider_id=provider_id, console_api_url=dify_config.CONSOLE_API_URL
|
||||
)
|
||||
service = ToolCredentialService(
|
||||
credentials=CredentialQueryRepository(session_factory=get_session_maker()),
|
||||
runtime=runtime,
|
||||
refresh_lock=RedisCredentialRefreshLock(client=redis_client),
|
||||
providers=providers,
|
||||
)
|
||||
return runtime.resolve(service=service, workspace_id=workspace_id, credential_id=credential_id)
|
||||
@@ -0,0 +1,109 @@
|
||||
"""Composition of the trace pipeline, Agent trace collection, and tracing provider configurations."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from configs import dify_config
|
||||
from enterprise.telemetry.exporter import is_enterprise_telemetry_enabled
|
||||
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
|
||||
from repositories.application_trace_repository import ApplicationTraceRepository
|
||||
from repositories.factory import DifyAPIRepositoryFactory
|
||||
from repositories.trace_record_repository import TraceRecordRepository
|
||||
from services.tracing.adapters import (
|
||||
CeleryExportRetryQueue,
|
||||
CeleryTraceEmitter,
|
||||
WorkspaceTracingSecretCipher,
|
||||
schedule_agent_trace_export,
|
||||
send_to_enterprise_telemetry,
|
||||
)
|
||||
from services.tracing.canonical import CanonicalTraceBuilder
|
||||
from services.tracing.collection import AgentTraceSettings
|
||||
from services.tracing.delivery import TraceDeliveryService
|
||||
from services.tracing.egress import SSRFEgress
|
||||
from services.tracing.provider_configs import ProviderConfigGateway, TraceProviderCapabilitiesQuery
|
||||
from services.tracing.providers import ProviderConfigCodec
|
||||
from services.tracing.registry import EntryPointTraceProviderCatalog
|
||||
from services.tracing.runtime_bridge import RuntimeApplicationTracingHooks
|
||||
from services.tracing.scopes import TraceScopes
|
||||
from services.tracing.service import ApplicationTracingService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TracingServices:
|
||||
scopes: TraceScopes
|
||||
delivery: TraceDeliveryService
|
||||
agent_traces: ApplicationTracingService
|
||||
hooks: RuntimeApplicationTracingHooks | None
|
||||
"""``None`` when the deployment does not collect Agent traces."""
|
||||
provider_configs: ProviderConfigGateway
|
||||
provider_capabilities: TraceProviderCapabilitiesQuery
|
||||
|
||||
|
||||
def build_tracing_services(*, database_client: sessionmaker[Session]) -> TracingServices:
|
||||
egress = SSRFEgress()
|
||||
providers = EntryPointTraceProviderCatalog()
|
||||
codec = ProviderConfigCodec(WorkspaceTracingSecretCipher())
|
||||
builder = CanonicalTraceBuilder()
|
||||
configs = SQLAlchemyAppTracingConfigRepository(session_factory=database_client)
|
||||
enterprise_telemetry = is_enterprise_telemetry_enabled()
|
||||
workflow_runs = DifyAPIRepositoryFactory.create_api_workflow_run_repository(database_client)
|
||||
node_executions = DifyAPIRepositoryFactory.create_api_workflow_node_execution_repository(database_client)
|
||||
agent_settings = AgentTraceSettings(
|
||||
enabled=dify_config.OPS_AGENT_TRACE_ENABLED,
|
||||
max_spans=dify_config.OPS_AGENT_TRACE_MAX_SPANS,
|
||||
max_bytes=dify_config.OPS_AGENT_TRACE_MAX_BYTES,
|
||||
collection_timeout_seconds=dify_config.OPS_AGENT_TRACE_COLLECTION_TIMEOUT,
|
||||
export_lease_seconds=dify_config.OPS_AGENT_TRACE_EXPORT_LEASE_SECONDS,
|
||||
max_export_attempts=dify_config.OPS_AGENT_TRACE_MAX_ATTEMPTS,
|
||||
retention_days=dify_config.OPS_AGENT_TRACE_RETENTION_DAYS,
|
||||
)
|
||||
agent_trace_runs = ApplicationTraceRepository(database_client)
|
||||
agent_traces = ApplicationTracingService(
|
||||
runs=agent_trace_runs,
|
||||
run_query=agent_trace_runs,
|
||||
sources=agent_trace_runs,
|
||||
# App, workspace, and credential names are enterprise telemetry dimensions only.
|
||||
records=TraceRecordRepository(
|
||||
database_client,
|
||||
workflow_runs=workflow_runs,
|
||||
node_executions=node_executions,
|
||||
files_url=dify_config.FILES_URL,
|
||||
enterprise_details=False,
|
||||
),
|
||||
builder=builder,
|
||||
providers=providers,
|
||||
codec=codec,
|
||||
egress=egress,
|
||||
schedule_export=schedule_agent_trace_export,
|
||||
settings=agent_settings,
|
||||
)
|
||||
return TracingServices(
|
||||
scopes=TraceScopes(
|
||||
emitter=CeleryTraceEmitter(), policies=configs, enterprise_enabled=is_enterprise_telemetry_enabled
|
||||
),
|
||||
delivery=TraceDeliveryService(
|
||||
records=TraceRecordRepository(
|
||||
database_client,
|
||||
workflow_runs=workflow_runs,
|
||||
node_executions=node_executions,
|
||||
files_url=dify_config.FILES_URL,
|
||||
enterprise_details=enterprise_telemetry,
|
||||
),
|
||||
destinations=configs,
|
||||
providers=providers,
|
||||
codec=codec,
|
||||
builder=builder,
|
||||
egress=egress,
|
||||
retries=CeleryExportRetryQueue(),
|
||||
enterprise_sink=send_to_enterprise_telemetry if enterprise_telemetry else None,
|
||||
collector=agent_traces if agent_settings.enabled else None,
|
||||
max_export_attempts=dify_config.OPS_TRACE_EXPORT_MAX_ATTEMPTS,
|
||||
),
|
||||
agent_traces=agent_traces,
|
||||
hooks=RuntimeApplicationTracingHooks(agent_traces) if agent_settings.enabled else None,
|
||||
provider_configs=ProviderConfigGateway(providers=providers, codec=codec, egress=egress),
|
||||
provider_capabilities=TraceProviderCapabilitiesQuery(
|
||||
providers=providers, api_collection_enabled=agent_settings.enabled
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,30 @@
|
||||
"""Composition of Trial App use cases."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from repositories.trial_app_repository import TrialAppRepository
|
||||
from services.trial_app_access_service import TrialAppAccessService
|
||||
from services.trial_app_generation_adapters import AppGenerateServiceRuntime
|
||||
from services.trial_app_generation_service import TrialAppGenerationService
|
||||
from services.trial_app_usage import TrialAppUsageRecorder
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TrialAppServices:
|
||||
access: TrialAppAccessService
|
||||
generation: TrialAppGenerationService
|
||||
usage: TrialAppUsageRecorder
|
||||
|
||||
|
||||
def build_trial_app_services(
|
||||
*, database_client: sessionmaker[Session], trial_apps: TrialAppRepository
|
||||
) -> TrialAppServices:
|
||||
return TrialAppServices(
|
||||
access=TrialAppAccessService(apps=trial_apps),
|
||||
generation=TrialAppGenerationService(
|
||||
runtime=AppGenerateServiceRuntime(session_factory=database_client), usage=trial_apps
|
||||
),
|
||||
usage=trial_apps,
|
||||
)
|
||||
@@ -0,0 +1,118 @@
|
||||
"""Compose workspace use cases with the shared account and workspace repositories."""
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from extensions.ext_redis import RedisClientWrapper
|
||||
from repositories.account.repository import SQLAlchemyAccountRepository
|
||||
from repositories.app.console_repository import ConsoleAppRepository
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
|
||||
from repositories.workspace.workspace_repository import WorkspaceRepository
|
||||
from services.account.adapters import RedisInvitationTokenStore
|
||||
from services.file_service import FileService
|
||||
from services.workspace.gateways import (
|
||||
DeploymentWorkspaceCreationPolicy,
|
||||
DeploymentWorkspaceFeatureGateway,
|
||||
DeploymentWorkspaceMemberAccessGateway,
|
||||
DeploymentWorkspaceMemberRoleResolver,
|
||||
DeploymentWorkspacePlanGateway,
|
||||
WorkspaceFileGateway,
|
||||
WorkspaceIdentityGateway,
|
||||
WorkspaceInvitationGateway,
|
||||
WorkspaceOwnerTransferGateway,
|
||||
WorkspaceProvisioningEffectsGateway,
|
||||
)
|
||||
from services.workspace.member_service import (
|
||||
InvitedAccountRegistration,
|
||||
WorkspaceInvitationService,
|
||||
WorkspaceMemberQueryService,
|
||||
WorkspaceMemberService,
|
||||
WorkspaceOwnerTransferService,
|
||||
)
|
||||
from services.workspace.provisioning_service import WorkspaceProvisioningService
|
||||
from services.workspace.resource_cleanup_service import WorkspaceResourceCleanupService
|
||||
from services.workspace.service import WorkspaceQueryService, WorkspaceService
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class WorkspaceServices:
|
||||
queries: WorkspaceQueryService
|
||||
management: WorkspaceService
|
||||
provisioning: WorkspaceProvisioningService
|
||||
members: WorkspaceMemberService
|
||||
member_queries: WorkspaceMemberQueryService
|
||||
owner_transfer: WorkspaceOwnerTransferService
|
||||
invitations: WorkspaceInvitationService
|
||||
identity: WorkspaceIdentityGateway
|
||||
resource_cleanup: WorkspaceResourceCleanupService
|
||||
|
||||
|
||||
def build_workspace_membership_services(
|
||||
*,
|
||||
workspaces: WorkspaceRepository,
|
||||
accounts: SQLAlchemyAccountRepository,
|
||||
) -> tuple[WorkspaceMemberService, WorkspaceProvisioningService]:
|
||||
"""Build the workspace prerequisites shared by account registration and invitations."""
|
||||
members = WorkspaceMemberService(
|
||||
workspaces=workspaces,
|
||||
accounts=accounts,
|
||||
access=DeploymentWorkspaceMemberAccessGateway(),
|
||||
)
|
||||
provisioning = WorkspaceProvisioningService(
|
||||
owners=accounts,
|
||||
provisioning=workspaces,
|
||||
effects=WorkspaceProvisioningEffectsGateway(),
|
||||
policies=DeploymentWorkspaceCreationPolicy(),
|
||||
memberships=workspaces,
|
||||
members=members,
|
||||
)
|
||||
return members, provisioning
|
||||
|
||||
|
||||
def build_workspace_services(
|
||||
*,
|
||||
database_client: sessionmaker[Session],
|
||||
workspaces: WorkspaceRepository,
|
||||
accounts: SQLAlchemyAccountRepository,
|
||||
files: FileService,
|
||||
redis: RedisClientWrapper,
|
||||
members: WorkspaceMemberService,
|
||||
provisioning: WorkspaceProvisioningService,
|
||||
registration: InvitedAccountRegistration,
|
||||
invitation_tokens: RedisInvitationTokenStore,
|
||||
) -> WorkspaceServices:
|
||||
return WorkspaceServices(
|
||||
queries=WorkspaceQueryService(workspaces=workspaces, plans=DeploymentWorkspacePlanGateway()),
|
||||
management=WorkspaceService(
|
||||
workspaces=workspaces,
|
||||
features=DeploymentWorkspaceFeatureGateway(),
|
||||
logos=WorkspaceFileGateway(files=files),
|
||||
),
|
||||
provisioning=provisioning,
|
||||
members=members,
|
||||
member_queries=WorkspaceMemberQueryService(
|
||||
members=workspaces,
|
||||
roles=DeploymentWorkspaceMemberRoleResolver(),
|
||||
),
|
||||
owner_transfer=WorkspaceOwnerTransferService(
|
||||
accounts=accounts,
|
||||
workspaces=workspaces,
|
||||
members=members,
|
||||
challenges=WorkspaceOwnerTransferGateway(redis=redis),
|
||||
),
|
||||
invitations=WorkspaceInvitationService(
|
||||
accounts=registration,
|
||||
workspaces=workspaces,
|
||||
members=members,
|
||||
invitations=WorkspaceInvitationGateway(tokens=invitation_tokens, redis=redis),
|
||||
),
|
||||
identity=WorkspaceIdentityGateway(workspaces=workspaces),
|
||||
resource_cleanup=WorkspaceResourceCleanupService(
|
||||
session_factory=database_client,
|
||||
apps=ConsoleAppRepository(session_factory=database_client),
|
||||
datasets=SQLAlchemyDatasetRepository(session_factory=database_client),
|
||||
agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),
|
||||
),
|
||||
)
|
||||
Reference in new issue
Block a user