fustor-fusion 0.1.7__tar.gz

fustor_fusion-0.1.7/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: fustor-fusion
+Version: 0.1.7
+Summary: Fusion service for Fustor
+Author-email: Huajin Wang <wanghuajin999@163.com>
+Requires-Python: >=3.11
+Requires-Dist: click
+Requires-Dist: fastapi[all]
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Requires-Dist: pydantic-settings
+Requires-Dist: greenlet==3.2.2
+Requires-Dist: sqlalchemy==2.0.41
+Requires-Dist: httpx
+Requires-Dist: fustor_registry_client
+Requires-Dist: python-json-logger>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"

fustor_fusion-0.1.7/docs/README.md

@@ -0,0 +1,17 @@
+# Fustor Fusion 服务文档
+
+本目录包含 Fustor Fusion 服务的相关文档。
+
+## 概述
+
+Fustor Fusion 服务负责从 Agent 接收数据，并进行数据摄取、处理和转换。它是 Fustor 平台中数据流的核心处理单元。
+
+## 模块
+
+*   **API**: 提供数据摄取 API 接口，供 Agent 服务调用。
+*   **Processors**: 包含各种数据处理和转换逻辑。
+*   **Models**: 定义了 Fusion 服务中使用的所有数据模型。
+
+## 更多信息
+
+*   **API 文档**: 访问 `/docs` (Swagger UI) 或 `/redoc` (ReDoc) 查看详细的 API 接口说明。

fustor_fusion-0.1.7/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "fustor-fusion"
+dynamic = ["version"]
+description = "Fusion service for Fustor"
+requires-python = ">=3.11"
+dependencies = [ "click", "fastapi[all]", "uvicorn", "pydantic", "pydantic-settings", "greenlet==3.2.2", "sqlalchemy==2.0.41", "httpx", "fustor_registry_client", "python-json-logger>=4.0.0",]
+[[project.authors]]
+name = "Huajin Wang"
+email = "wanghuajin999@163.com"
+
+[build-system]
+requires = [ "setuptools>=61.0", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+root = ".."
+version_scheme = "post-release"
+local_scheme = "dirty-tag"
+
+["project.urls"]
+Homepage = "https://github.com/excelwang/fustor/fusion"
+"Bug Tracker" = "https://github.com/excelwang/fustor/issues"
+
+license = "MIT"
+
+[project.optional-dependencies]
+dev = [ "pytest>=8.0.0", "ruff>=0.1.0", "mypy>=1.0.0", "pytest-asyncio>=0.23.0",]
+
+[project.scripts]
+fustor-fusion = "fustor_fusion.cli:cli"
+
+[tool.setuptools.packages.find]
+where = [ "src",]

fustor_fusion-0.1.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fustor_fusion-0.1.7/src/fustor_fusion/api/ingestion.py

@@ -0,0 +1,189 @@
+from fastapi import APIRouter, Depends, status, HTTPException, Query, Request
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+import logging
+from typing import List, Dict, Any
+import time
+
+from ..auth.dependencies import get_datastore_id_from_api_key
+from ..runtime import datastore_event_manager
+from ..core.session_manager import session_manager
+from ..auth.datastore_cache import datastore_config_cache
+from ..datastore_state_manager import datastore_state_manager
+
+# Import the queue-based ingestion
+from ..queue_integration import queue_based_ingestor, add_events_batch_to_queue, get_position_from_queue, update_position_in_queue
+from fustor_event_model.models import EventBase, EventType # Import EventBase and EventType
+
+from ..parsers.manager import ParserManager, get_directory_stats # CORRECTED
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+ingestion_router = APIRouter(tags=["Ingestion"])
+
+@ingestion_router.get("/stats", summary="Get global ingestion statistics")
+async def get_global_stats():
+    """
+    Get aggregated statistics across all active datastores for the monitoring dashboard.
+    """
+    active_datastores = datastore_config_cache.get_all_active_datastores()
+    
+    sources = []
+    total_volume = 0
+    min_latency_ms = None # Use None to indicate no data
+    oldest_dir_info = {"path": "N/A", "age_days": 0}
+    max_staleness_seconds = -1
+
+    now = datetime.now().timestamp()
+
+    for ds_config in active_datastores:
+        ds_id = ds_config.id
+        sources.append({
+            "id": ds_config.name or f"Datastore {ds_id}",
+            "type": "Fusion" # Or derive from config if available
+        })
+
+        try:
+            stats = await get_directory_stats(datastore_id=ds_id)
+            
+            # 1. Volume
+            total_volume += stats.get("total_files", 0)
+
+            # 2. Latency (Freshness)
+            # We want the SMALLEST gap between now and the latest file time (i.e., most fresh)
+            latest_ts = stats.get("latest_file_timestamp")
+            if latest_ts:
+                latency = (now - latest_ts) * 1000 # ms
+                # Latency can't be negative ideally, but clocks vary
+                latency = max(0, latency) 
+                
+                if min_latency_ms is None or latency < min_latency_ms:
+                    min_latency_ms = latency
+
+            # 3. Staleness (Oldest Directory)
+            # We want the LARGEST gap between now and the oldest directory time
+            oldest = stats.get("oldest_directory")
+            if oldest and oldest.get("timestamp"):
+                age_seconds = now - oldest["timestamp"]
+                if age_seconds > max_staleness_seconds:
+                    max_staleness_seconds = age_seconds
+                    oldest_dir_info = {
+                        "path": f"[{ds_config.name}] {oldest['path']}",
+                        "age_days": int(age_seconds / 86400)
+                    }
+
+        except Exception as e:
+            logger.error(f"Failed to get stats for datastore {ds_id}: {e}")
+
+    return {
+        "sources": sources,
+        "metrics": {
+            "total_volume": total_volume,
+            "latency_ms": int(min_latency_ms) if min_latency_ms is not None else 0,
+            "oldest_directory": oldest_dir_info
+        }
+    }
+
+
+@ingestion_router.get("/position", summary="获取同步源的最新检查点位置")
+async def get_position(
+    session_id: str = Query(..., description="同步源的唯一 ID"),
+    datastore_id=Depends(get_datastore_id_from_api_key),
+):
+    si = await session_manager.get_session_info(datastore_id, session_id)
+    if not si:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    # Get position from memory queue
+    position_index = await get_position_from_queue(datastore_id, si.task_id)
+    
+    if position_index is not None:
+        return {"index": position_index}
+    else:
+        # No position found
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="该同步源的检查点未找到，建议触发快照同步")
+
+# --- Pydantic Models for Ingestion ---
+class BatchIngestPayload(BaseModel):
+    """
+    Defines the generic payload for receiving a batch of events from any client.
+    """
+    session_id: str
+    events: List[Dict[str, Any]] # Events are received as dicts
+    source_type: str # 'message' or 'snapshot'
+# --- End Ingestion Models ---
+
+
+@ingestion_router.post(
+    "/",
+    summary="接收批量事件",
+    description="此端点用于从客户端接收批量事件。",
+    status_code=status.HTTP_204_NO_CONTENT
+)
+async def ingest_event_batch(
+    payload: BatchIngestPayload,
+    request: Request,
+    datastore_id=Depends(get_datastore_id_from_api_key),
+):
+    si = await session_manager.get_session_info(datastore_id, payload.session_id)
+    if not si:
+        raise HTTPException(status_code=404, detail="Session not found")
+    await session_manager.keep_session_alive(
+        datastore_id, 
+        payload.session_id,
+        client_ip=request.client.host # Assuming request is available here
+    )
+
+    # NEW: Check for outdated snapshot pushes
+    datastore_config = datastore_config_cache.get_datastore_config(datastore_id)
+    if datastore_config and datastore_config.allow_concurrent_push and payload.source_type == 'snapshot':
+        is_authoritative = await datastore_state_manager.is_authoritative_session(datastore_id, payload.session_id)
+        if not is_authoritative:
+            logger.warning(f"Received snapshot push from outdated session '{payload.session_id}' for datastore {datastore_id}. Rejecting with 419.")
+            raise HTTPException(status_code=419, detail="A newer sync session has been started. This snapshot task is now obsolete and should stop.")
+
+    try:
+        if payload.events:
+            latest_index = 0
+            event_objects_to_add: List[EventBase] = []
+            for event_dict in payload.events:
+                # Infer event_type, schema, table, index, and fields from the dict
+                # Default to UPDATE if not specified, as it's the most common for generic data
+                event_type = EventType(event_dict.get("event_type", EventType.UPDATE.value))
+                event_schema = event_dict.get("event_schema", "default_schema") # Use event_schema
+                table = event_dict.get("table", "default_table")
+                index = event_dict.get("index", -1)
+                rows = event_dict.get("rows", [])
+                fields = event_dict.get("fields", list(rows[0].keys()) if rows else [])
+
+                # Create EventBase object
+                event_obj = EventBase(
+                    event_type=event_type,
+                    event_schema=event_schema, # Use event_schema
+                    table=table,
+                    index=index,
+                    rows=rows,
+                    fields=fields
+                )
+                event_objects_to_add.append(event_obj)
+
+                if isinstance(index, int):
+                    latest_index = max(latest_index, index)
+
+            # Update position in memory queue
+            if latest_index > 0:
+                await update_position_in_queue(datastore_id, si.task_id, latest_index)
+
+            # Add events to the in-memory queue for high-throughput ingestion
+            # Pass task_id for position tracking
+            total_events_added = await add_events_batch_to_queue(datastore_id, event_objects_to_add, si.task_id)
+            
+        # Notify the background task that there are new events
+        try:
+            await datastore_event_manager.notify(datastore_id)
+        except Exception as e:
+            logger.error(f"Failed to notify event manager for datastore {datastore_id}: {e}", exc_info=True)
+
+    except Exception as e:
+        logger.error(f"处理批量事件失败 (task: {si.task_id}): {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"推送批量事件失败: {str(e)}")

fustor_fusion-0.1.7/src/fustor_fusion/api/session.py

@@ -0,0 +1,194 @@
+from fastapi import APIRouter, Depends, status, HTTPException, Header, Query, Request
+from pydantic import BaseModel
+import logging
+from typing import List, Dict, Any, Optional
+import time
+import uuid
+
+from ..auth.dependencies import get_datastore_id_from_api_key
+from ..auth.datastore_cache import datastore_config_cache, DatastoreConfig
+from ..core.session_manager import session_manager
+from ..datastore_state_manager import datastore_state_manager
+from ..parsers.manager import reset_directory_tree
+
+logger = logging.getLogger(__name__)
+session_router = APIRouter(tags=["Session Management"])
+
+# --- Pydantic Models for Session Creation ---
+class CreateSessionPayload(BaseModel):
+    """Payload for creating a new session"""
+    task_id: str
+    client_info: Optional[Dict[str, Any]] = None
+
+# --- End Session Creation Models ---
+
+async def _should_allow_new_session(datastore_config: DatastoreConfig, datastore_id: int, task_id: str, session_id: str) -> bool:
+    """
+    Determine if a new session should be allowed based on datastore configuration and current active sessions
+    """
+    sessions = await session_manager.get_datastore_sessions(datastore_id)
+    active_session_ids = set(sessions.keys())
+
+    logger.debug(f"Checking if new session {session_id} for task {task_id} should be allowed on datastore {datastore_id}")
+    logger.debug(f"Current active sessions: {list(active_session_ids)}")
+    logger.debug(f"Datastore allows concurrent push: {datastore_config.allow_concurrent_push}")
+
+    if datastore_config.allow_concurrent_push:
+        # If concurrent pushes are allowed, we only care about sessions for the same task_id
+        current_task_sessions = [
+            s_info for s_id, s_info in sessions.items()
+            if s_info.task_id == task_id
+        ]
+        logger.debug(f"Current sessions for task {task_id}: {len(current_task_sessions)}")
+        return len(current_task_sessions) == 0
+    else:
+        # If concurrent pushes are not allowed, the datastore acts as a global lock
+        locked_session_id = await datastore_state_manager.get_locked_session_id(datastore_id)
+        logger.debug(f"Datastore {datastore_id} is locked by session: {locked_session_id}")
+
+        if not locked_session_id:
+            # Not locked, so a new session is allowed
+            logger.debug(f"Datastore {datastore_id} is not locked. Allowing new session.")
+            return True
+
+        # The datastore is locked. Check if the lock is stale.
+        if locked_session_id not in active_session_ids:
+            # The session holding the lock is no longer in the active session manager.
+            # This indicates a stale lock (e.g., from a previous crashed instance).
+            logger.warning(f"Datastore {datastore_id} is locked by a stale session {locked_session_id} that is no longer active. Unlocking automatically.")
+            await datastore_state_manager.unlock_for_session(datastore_id, locked_session_id)
+            return True # Allow the new session to proceed
+        else:
+            # The datastore is locked by a currently active session.
+            logger.warning(f"Datastore {datastore_id} is locked by an active session {locked_session_id}. Denying new session {session_id}.")
+            return False
+
+@session_router.post("/", 
+    summary="创建新的同步会话", 
+    description="为新的同步任务创建会话ID并注册会话")
+async def create_session(
+    payload: CreateSessionPayload,
+    request: Request,
+    datastore_id: int = Depends(get_datastore_id_from_api_key),
+):
+    # Get datastore configuration from cache
+    datastore_config = datastore_config_cache.get_datastore_config(datastore_id)
+    
+    if not datastore_config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, 
+            detail=f"Configuration for Datastore {datastore_id} not found"
+        )
+    
+    session_id = str(uuid.uuid4())
+    
+    should_allow_new_session = await _should_allow_new_session(
+        datastore_config, datastore_id, payload.task_id, session_id
+    )
+    
+    if not should_allow_new_session:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="New session cannot be created due to current active sessions"
+        )
+    
+    if datastore_config.allow_concurrent_push:
+        logger.info(f"Datastore {datastore_id} allows concurrent push. Setting new authoritative session {session_id} and resetting parser.")
+        
+        # 1. Set the new session as authoritative
+        await datastore_state_manager.set_authoritative_session(datastore_id, session_id)
+
+        # 2. Reset the parser state (memory only)
+        try:
+            await reset_directory_tree(datastore_id)
+            logger.info(f"Successfully reset parser for datastore {datastore_id}.")
+        except Exception as e:
+            logger.error(f"Exception during parser reset for datastore {datastore_id}: {e}", exc_info=True)
+
+    client_ip = request.client.host
+    
+    await session_manager.create_session_entry(
+        datastore_id, 
+        session_id, 
+        task_id=payload.task_id,
+        client_ip=client_ip,
+        allow_concurrent_push=datastore_config.allow_concurrent_push,
+        session_timeout_seconds=datastore_config.session_timeout_seconds
+    )
+    
+    if not datastore_config.allow_concurrent_push:
+        await datastore_state_manager.lock_for_session(datastore_id, session_id)
+    
+    return {
+        "session_id": session_id,
+        "suggested_heartbeat_interval_seconds": max(1, datastore_config.session_timeout_seconds // 2),
+        "session_timeout_seconds": datastore_config.session_timeout_seconds
+    }
+
+@session_router.post("/heartbeat", tags=["Session Management"], summary="会话心跳保活")
+async def heartbeat(
+    request: Request,
+    datastore_id: int = Depends(get_datastore_id_from_api_key),
+    session_id: str = Header(..., description="会话ID"),
+):
+    si = await session_manager.get_session_info(datastore_id, session_id)
+    
+    if not si:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, 
+            detail=f"Session {session_id} not found"
+        )
+    
+    is_locked_by_session = await datastore_state_manager.is_locked_by_session(datastore_id, session_id)
+    if not is_locked_by_session:
+        await datastore_state_manager.lock_for_session(datastore_id, session_id)
+    
+    await session_manager.keep_session_alive(datastore_id, session_id, client_ip=request.client.host)
+    return {
+        "status": "ok", 
+        "message": f"Session {session_id} heartbeat updated successfully",
+    }
+
+@session_router.delete("/", tags=["Session Management"], summary="结束会话")
+async def end_session(
+    datastore_id: int = Depends(get_datastore_id_from_api_key),
+    session_id: str = Header(..., description="会话ID"),
+):
+    success = await session_manager.terminate_session(datastore_id, session_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, 
+            detail=f"Session {session_id} not found"
+        )
+    
+    await datastore_state_manager.unlock_for_session(datastore_id, session_id)
+    
+    return {
+        "status": "ok",
+        "message": f"Session {session_id} terminated successfully",
+    }
+
+@session_router.get("/", tags=["Session Management"], summary="获取活动会话列表")
+async def list_sessions(
+    datastore_id: int = Depends(get_datastore_id_from_api_key),
+):
+    sessions = await session_manager.get_datastore_sessions(datastore_id)
+    
+    session_list = []
+    for session_id, session_info in sessions.items():
+        session_list.append({
+            "session_id": session_id,
+            "task_id": session_info.task_id,
+            "client_ip": session_info.client_ip,
+            "last_activity": session_info.last_activity,
+            "created_at": session_info.created_at,
+            "allow_concurrent_push": session_info.allow_concurrent_push,
+            "session_timeout_seconds": session_info.session_timeout_seconds
+        })
+    
+    return {
+        "datastore_id": datastore_id,
+        "active_sessions": session_list,
+        "count": len(session_list)
+    }

fustor_fusion-0.1.7/src/fustor_fusion/api/views.py

@@ -0,0 +1,71 @@
+"""
+API endpoints for the parsers module.
+Provides REST endpoints to access parsed data views.
+"""
+from fastapi import APIRouter, Query, Header, Depends, status, HTTPException
+import logging
+from typing import Dict, Any, Optional
+
+from ..parsers.manager import get_directory_tree, search_files, get_directory_stats, reset_directory_tree
+from ..auth.dependencies import get_datastore_id_from_api_key
+
+logger = logging.getLogger(__name__)
+
+parser_router = APIRouter(tags=["Parsers - Data Views"])
+
+
+@parser_router.get("/fs/tree", summary="Get directory tree structure")
+async def get_directory_tree_api(
+    path: str = Query("/", description="Directory path to retrieve (default: '/')"),
+    datastore_id: int = Depends(get_datastore_id_from_api_key)
+) -> Optional[Dict[str, Any]]:
+    """Get the directory structure tree starting from the specified path."""
+    logger.info(f"API request for directory tree: path={path}, datastore_id={datastore_id}")
+    result = await get_directory_tree(path, datastore_id=datastore_id)
+    logger.info(f"Directory tree result for path '{path}': {result}")
+    return result
+
+@parser_router.get("/fs/search", summary="Search for files by pattern")
+async def search_files_api(
+    pattern: str = Query(..., description="Search pattern to match in file paths"),
+    datastore_id: int = Depends(get_datastore_id_from_api_key)
+) -> list:
+    """Search for files matching the specified pattern."""
+    logger.info(f"API request for file search: pattern={pattern}, datastore_id={datastore_id}")
+    result = await search_files(pattern, datastore_id=datastore_id)
+    logger.info(f"File search result for pattern '{pattern}': found {len(result)} files")
+    return result
+
+
+@parser_router.get("/fs/stats", summary="Get statistics about the directory structure")
+async def get_directory_stats_api(
+    datastore_id: int = Depends(get_datastore_id_from_api_key)
+) -> Dict[str, Any]:
+    """Get statistics about the current directory structure."""
+    logger.info(f"API request for directory stats: datastore_id={datastore_id}")
+    result = await get_directory_stats(datastore_id=datastore_id)
+    logger.info(f"Directory stats result: {result}")
+    return result
+
+
+@parser_router.delete("/fs/reset", 
+    summary="Reset directory tree structure",
+    description="Clear all directory entries for a specific datastore",
+    status_code=status.HTTP_204_NO_CONTENT
+)
+async def reset_directory_tree_api(
+    datastore_id: int = Depends(get_datastore_id_from_api_key)
+) -> None:
+    """
+    Reset the directory tree structure by clearing all entries for a specific datastore.
+    """
+    logger.info(f"API request to reset directory tree for datastore {datastore_id}")
+    success = await reset_directory_tree(datastore_id)
+    
+    if not success:
+        logger.error(f"Failed to reset directory tree for datastore {datastore_id}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to reset directory tree"
+        )
+    logger.info(f"Successfully reset directory tree for datastore {datastore_id}")

fustor_fusion-0.1.7/src/fustor_fusion/auth/cache.py

@@ -0,0 +1,21 @@
+from typing import Dict, Optional, List, Any
+from fustor_fusion_sdk.interfaces import ApiKeyCacheInterface # Import the interface
+
+class ApiKeyCache(ApiKeyCacheInterface): # Inherit from the interface
+    def __init__(self):
+        self._cache: Dict[str, int] = {}
+
+    def set_cache(self, api_keys_data: List[Dict[str, Any]]):
+        """
+        Sets the entire cache from a list of API key data.
+        Expected format: [{'key': '...', 'datastore_id': 1}, ...]
+        """
+        new_cache = {item['key']: item['datastore_id'] for item in api_keys_data if 'key' in item and 'datastore_id' in item}
+        self._cache = new_cache
+    def get_datastore_id(self, api_key: str) -> Optional[int]:
+        """
+        Retrieves the datastore_id for a given API key.
+        """
+        return self._cache.get(api_key)
+
+api_key_cache = ApiKeyCache()

fustor_fusion-0.1.7/src/fustor_fusion/auth/datastore_cache.py

@@ -0,0 +1,24 @@
+from typing import Dict, Optional, List, Any
+from fustor_common.models import DatastoreConfig
+from fustor_registry_client.models import ClientDatastoreConfigResponse
+from fustor_fusion_sdk.interfaces import DatastoreConfigCacheInterface # Import the interface
+
+class DatastoreConfigCache(DatastoreConfigCacheInterface): # Inherit from the interface
+    def __init__(self):
+        self._cache: Dict[int, DatastoreConfig] = {}
+
+    def set_cache(self, datastore_configs_data: List[ClientDatastoreConfigResponse]): # Changed type hint
+        """
+        Sets the entire cache from a list of datastore config data.
+        """
+        new_cache = {item.datastore_id: item for item in datastore_configs_data} # Store the full ClientDatastoreConfigResponse object
+        self._cache = new_cache
+        print(f"Datastore config cache updated. Total datastores: {len(self._cache)}")
+
+    def get_datastore_config(self, datastore_id: int) -> Optional[DatastoreConfig]:
+        """
+        Retrieves the configuration for a given datastore.
+        """
+        return self._cache.get(datastore_id)
+
+datastore_config_cache = DatastoreConfigCache()

fustor_fusion-0.1.7/src/fustor_fusion/auth/dependencies.py

@@ -0,0 +1,21 @@
+from fastapi import Header, HTTPException, status, Depends
+from typing import Optional
+import logging
+
+from .cache import api_key_cache
+
+logger = logging.getLogger(__name__)
+
+async def get_datastore_id_from_api_key(x_api_key: str = Header(..., alias="X-API-Key")) -> int:
+    """
+    Retrieves the datastore_id from the in-memory API key cache.
+    """
+    logger.debug(f"Received X-API-Key: {x_api_key}")
+    datastore_id = api_key_cache.get_datastore_id(x_api_key)
+    logger.debug(f"Resolved datastore_id for key '{x_api_key[:5]}...': {datastore_id}")
+    if datastore_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or inactive X-API-Key"
+        )
+    return datastore_id