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.

3.3 KB
Raw Blame
import json
from http import HTTPStatus
from typing import Never
from urllib.parse import urljoin

import httpx

from core.helper import ssrf_proxy
from services.auth.errors import (
    DataSourceApiKeyAuthCredentialValidationError,
    DataSourceApiKeyAuthProviderUnavailableError,
    InvalidDataSourceApiKeyAuthCredentialsError,
)
from services.data_source.entities.api_key_auth import DataSourceApiKeyAuthCredentials

# Explicit bounded timeout for credential-validation requests so a slow or
# hanging WaterCrawl endpoint cannot block the worker indefinitely.
_CREDENTIAL_TIMEOUT = httpx.Timeout(10.0)


class WatercrawlAuth:
    def __init__(self, credentials: DataSourceApiKeyAuthCredentials):
        if credentials.auth_type != "x-api-key":
            raise InvalidDataSourceApiKeyAuthCredentialsError(
                "Invalid auth type, WaterCrawl auth type must be x-api-key"
            )
        self.api_key = credentials.api_key
        self.base_url = credentials.options.get("base_url", "https://app.watercrawl.dev")

        if not self.api_key:
            raise InvalidDataSourceApiKeyAuthCredentialsError("No API key provided")

    def validate_credentials(self) -> bool:
        headers = self._prepare_headers()
        url = urljoin(self.base_url, "/api/v1/core/crawl-requests/")
        response = self._get_request(url, headers)
        if response.status_code == 200:
            return True
        else:
            self._handle_error(response)

    def _prepare_headers(self):
        return {"Content-Type": "application/json", "X-API-KEY": self.api_key}

    def _get_request(self, url, headers):
        return ssrf_proxy.get(url, headers=headers, timeout=_CREDENTIAL_TIMEOUT, max_retries=0)

    def _handle_error(self, response) -> Never:
        if (
            response.status_code == HTTPStatus.TOO_MANY_REQUESTS
            or response.status_code >= HTTPStatus.INTERNAL_SERVER_ERROR
        ):
            raise DataSourceApiKeyAuthProviderUnavailableError("watercrawl", response.status_code)

        if response.status_code in {402, 409}:
            error_message = _error_field(response.text)
            if error_message is None:
                error_message = response.text or "Unknown error occurred"
            raise DataSourceApiKeyAuthCredentialValidationError(
                f"Failed to authorize. Status code: {response.status_code}. Error: {error_message}"
            )
        else:
            if response.text:
                error_message = _error_field(response.text)
                if error_message is None:
                    error_message = response.text
                raise DataSourceApiKeyAuthCredentialValidationError(
                    f"Failed to authorize. Status code: {response.status_code}. Error: {error_message}"
                )
            raise DataSourceApiKeyAuthCredentialValidationError(
                f"Unexpected error occurred while trying to authorize. Status code: {response.status_code}"
            )


def _error_field(body: str) -> str | None:
    """The `error` field of a JSON object body, or None when the body is not a JSON object."""
    try:
        payload = json.loads(body)
    except json.JSONDecodeError:
        return None
    if not isinstance(payload, dict):
        return None
    return payload.get("error", "Unknown error occurred")