315 lines
13 KiB
Python
Executable File
315 lines
13 KiB
Python
Executable File
# [DEF:SettingsRouter:Module]
|
|
#
|
|
# @SEMANTICS: settings, api, router, fastapi
|
|
# @PURPOSE: Provides API endpoints for managing application settings and Superset environments.
|
|
# @LAYER: UI (API)
|
|
# @RELATION: DEPENDS_ON -> ConfigManager
|
|
# @RELATION: DEPENDS_ON -> ConfigModels
|
|
#
|
|
# @INVARIANT: All settings changes must be persisted via ConfigManager.
|
|
# @PUBLIC_API: router
|
|
|
|
# [SECTION: IMPORTS]
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from typing import List
|
|
from pydantic import BaseModel
|
|
from ...core.config_models import AppConfig, Environment, GlobalSettings, LoggingConfig
|
|
from ...models.storage import StorageConfig
|
|
from ...dependencies import get_config_manager, has_permission
|
|
from ...core.config_manager import ConfigManager
|
|
from ...core.logger import logger, belief_scope
|
|
from ...core.superset_client import SupersetClient
|
|
# [/SECTION]
|
|
|
|
# [DEF:LoggingConfigResponse:Class]
|
|
# @PURPOSE: Response model for logging configuration with current task log level.
|
|
# @SEMANTICS: logging, config, response
|
|
class LoggingConfigResponse(BaseModel):
|
|
level: str
|
|
task_log_level: str
|
|
enable_belief_state: bool
|
|
# [/DEF:LoggingConfigResponse:Class]
|
|
|
|
router = APIRouter()
|
|
|
|
# [DEF:get_settings:Function]
|
|
# @PURPOSE: Retrieves all application settings.
|
|
# @PRE: Config manager is available.
|
|
# @POST: Returns masked AppConfig.
|
|
# @RETURN: AppConfig - The current configuration.
|
|
@router.get("", response_model=AppConfig)
|
|
async def get_settings(
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "READ"))
|
|
):
|
|
with belief_scope("get_settings"):
|
|
logger.info("[get_settings][Entry] Fetching all settings")
|
|
config = config_manager.get_config().copy(deep=True)
|
|
# Mask passwords
|
|
for env in config.environments:
|
|
if env.password:
|
|
env.password = "********"
|
|
return config
|
|
# [/DEF:get_settings:Function]
|
|
|
|
# [DEF:update_global_settings:Function]
|
|
# @PURPOSE: Updates global application settings.
|
|
# @PRE: New settings are provided.
|
|
# @POST: Global settings are updated.
|
|
# @PARAM: settings (GlobalSettings) - The new global settings.
|
|
# @RETURN: GlobalSettings - The updated settings.
|
|
@router.patch("/global", response_model=GlobalSettings)
|
|
async def update_global_settings(
|
|
settings: GlobalSettings,
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "WRITE"))
|
|
):
|
|
with belief_scope("update_global_settings"):
|
|
logger.info("[update_global_settings][Entry] Updating global settings")
|
|
|
|
config_manager.update_global_settings(settings)
|
|
return settings
|
|
# [/DEF:update_global_settings:Function]
|
|
|
|
# [DEF:get_storage_settings:Function]
|
|
# @PURPOSE: Retrieves storage-specific settings.
|
|
# @RETURN: StorageConfig - The storage configuration.
|
|
@router.get("/storage", response_model=StorageConfig)
|
|
async def get_storage_settings(
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "READ"))
|
|
):
|
|
with belief_scope("get_storage_settings"):
|
|
return config_manager.get_config().settings.storage
|
|
# [/DEF:get_storage_settings:Function]
|
|
|
|
# [DEF:update_storage_settings:Function]
|
|
# @PURPOSE: Updates storage-specific settings.
|
|
# @PARAM: storage (StorageConfig) - The new storage settings.
|
|
# @POST: Storage settings are updated and saved.
|
|
# @RETURN: StorageConfig - The updated storage settings.
|
|
@router.put("/storage", response_model=StorageConfig)
|
|
async def update_storage_settings(
|
|
storage: StorageConfig,
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "WRITE"))
|
|
):
|
|
with belief_scope("update_storage_settings"):
|
|
is_valid, message = config_manager.validate_path(storage.root_path)
|
|
if not is_valid:
|
|
raise HTTPException(status_code=400, detail=message)
|
|
|
|
settings = config_manager.get_config().settings
|
|
settings.storage = storage
|
|
config_manager.update_global_settings(settings)
|
|
return config_manager.get_config().settings.storage
|
|
# [/DEF:update_storage_settings:Function]
|
|
|
|
# [DEF:get_environments:Function]
|
|
# @PURPOSE: Lists all configured Superset environments.
|
|
# @PRE: Config manager is available.
|
|
# @POST: Returns list of environments.
|
|
# @RETURN: List[Environment] - List of environments.
|
|
@router.get("/environments", response_model=List[Environment])
|
|
async def get_environments(
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "READ"))
|
|
):
|
|
with belief_scope("get_environments"):
|
|
logger.info("[get_environments][Entry] Fetching environments")
|
|
return config_manager.get_environments()
|
|
# [/DEF:get_environments:Function]
|
|
|
|
# [DEF:add_environment:Function]
|
|
# @PURPOSE: Adds a new Superset environment.
|
|
# @PRE: Environment data is valid and reachable.
|
|
# @POST: Environment is added to config.
|
|
# @PARAM: env (Environment) - The environment to add.
|
|
# @RETURN: Environment - The added environment.
|
|
@router.post("/environments", response_model=Environment)
|
|
async def add_environment(
|
|
env: Environment,
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "WRITE"))
|
|
):
|
|
with belief_scope("add_environment"):
|
|
logger.info(f"[add_environment][Entry] Adding environment {env.id}")
|
|
|
|
# Validate connection before adding
|
|
try:
|
|
client = SupersetClient(env)
|
|
client.get_dashboards(query={"page_size": 1})
|
|
except Exception as e:
|
|
logger.error(f"[add_environment][Coherence:Failed] Connection validation failed: {e}")
|
|
raise HTTPException(status_code=400, detail=f"Connection validation failed: {e}")
|
|
|
|
config_manager.add_environment(env)
|
|
return env
|
|
# [/DEF:add_environment:Function]
|
|
|
|
# [DEF:update_environment:Function]
|
|
# @PURPOSE: Updates an existing Superset environment.
|
|
# @PRE: ID and valid environment data are provided.
|
|
# @POST: Environment is updated in config.
|
|
# @PARAM: id (str) - The ID of the environment to update.
|
|
# @PARAM: env (Environment) - The updated environment data.
|
|
# @RETURN: Environment - The updated environment.
|
|
@router.put("/environments/{id}", response_model=Environment)
|
|
async def update_environment(
|
|
id: str,
|
|
env: Environment,
|
|
config_manager: ConfigManager = Depends(get_config_manager)
|
|
):
|
|
with belief_scope("update_environment"):
|
|
logger.info(f"[update_environment][Entry] Updating environment {id}")
|
|
|
|
# If password is masked, we need the real one for validation
|
|
env_to_validate = env.copy(deep=True)
|
|
if env_to_validate.password == "********":
|
|
old_env = next((e for e in config_manager.get_environments() if e.id == id), None)
|
|
if old_env:
|
|
env_to_validate.password = old_env.password
|
|
|
|
# Validate connection before updating
|
|
try:
|
|
client = SupersetClient(env_to_validate)
|
|
client.get_dashboards(query={"page_size": 1})
|
|
except Exception as e:
|
|
logger.error(f"[update_environment][Coherence:Failed] Connection validation failed: {e}")
|
|
raise HTTPException(status_code=400, detail=f"Connection validation failed: {e}")
|
|
|
|
if config_manager.update_environment(id, env):
|
|
return env
|
|
raise HTTPException(status_code=404, detail=f"Environment {id} not found")
|
|
# [/DEF:update_environment:Function]
|
|
|
|
# [DEF:delete_environment:Function]
|
|
# @PURPOSE: Deletes a Superset environment.
|
|
# @PRE: ID is provided.
|
|
# @POST: Environment is removed from config.
|
|
# @PARAM: id (str) - The ID of the environment to delete.
|
|
@router.delete("/environments/{id}")
|
|
async def delete_environment(
|
|
id: str,
|
|
config_manager: ConfigManager = Depends(get_config_manager)
|
|
):
|
|
with belief_scope("delete_environment"):
|
|
logger.info(f"[delete_environment][Entry] Deleting environment {id}")
|
|
config_manager.delete_environment(id)
|
|
return {"message": f"Environment {id} deleted"}
|
|
# [/DEF:delete_environment:Function]
|
|
|
|
# [DEF:test_environment_connection:Function]
|
|
# @PURPOSE: Tests the connection to a Superset environment.
|
|
# @PRE: ID is provided.
|
|
# @POST: Returns success or error status.
|
|
# @PARAM: id (str) - The ID of the environment to test.
|
|
# @RETURN: dict - Success message or error.
|
|
@router.post("/environments/{id}/test")
|
|
async def test_environment_connection(
|
|
id: str,
|
|
config_manager: ConfigManager = Depends(get_config_manager)
|
|
):
|
|
with belief_scope("test_environment_connection"):
|
|
logger.info(f"[test_environment_connection][Entry] Testing environment {id}")
|
|
|
|
# Find environment
|
|
env = next((e for e in config_manager.get_environments() if e.id == id), None)
|
|
if not env:
|
|
raise HTTPException(status_code=404, detail=f"Environment {id} not found")
|
|
|
|
try:
|
|
# Initialize client (this will trigger authentication)
|
|
client = SupersetClient(env)
|
|
|
|
# Try a simple request to verify
|
|
client.get_dashboards(query={"page_size": 1})
|
|
|
|
logger.info(f"[test_environment_connection][Coherence:OK] Connection successful for {id}")
|
|
return {"status": "success", "message": "Connection successful"}
|
|
except Exception as e:
|
|
logger.error(f"[test_environment_connection][Coherence:Failed] Connection failed for {id}: {e}")
|
|
return {"status": "error", "message": str(e)}
|
|
# [/DEF:test_environment_connection:Function]
|
|
|
|
# [DEF:get_logging_config:Function]
|
|
# @PURPOSE: Retrieves current logging configuration.
|
|
# @PRE: Config manager is available.
|
|
# @POST: Returns logging configuration.
|
|
# @RETURN: LoggingConfigResponse - The current logging config.
|
|
@router.get("/logging", response_model=LoggingConfigResponse)
|
|
async def get_logging_config(
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "READ"))
|
|
):
|
|
with belief_scope("get_logging_config"):
|
|
logging_config = config_manager.get_config().settings.logging
|
|
return LoggingConfigResponse(
|
|
level=logging_config.level,
|
|
task_log_level=logging_config.task_log_level,
|
|
enable_belief_state=logging_config.enable_belief_state
|
|
)
|
|
# [/DEF:get_logging_config:Function]
|
|
|
|
# [DEF:update_logging_config:Function]
|
|
# @PURPOSE: Updates logging configuration.
|
|
# @PRE: New logging config is provided.
|
|
# @POST: Logging configuration is updated and saved.
|
|
# @PARAM: config (LoggingConfig) - The new logging configuration.
|
|
# @RETURN: LoggingConfigResponse - The updated logging config.
|
|
@router.patch("/logging", response_model=LoggingConfigResponse)
|
|
async def update_logging_config(
|
|
config: LoggingConfig,
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "WRITE"))
|
|
):
|
|
with belief_scope("update_logging_config"):
|
|
logger.info(f"[update_logging_config][Entry] Updating logging config: level={config.level}, task_log_level={config.task_log_level}")
|
|
|
|
# Get current settings and update logging config
|
|
settings = config_manager.get_config().settings
|
|
settings.logging = config
|
|
config_manager.update_global_settings(settings)
|
|
|
|
return LoggingConfigResponse(
|
|
level=config.level,
|
|
task_log_level=config.task_log_level,
|
|
enable_belief_state=config.enable_belief_state
|
|
)
|
|
# [/DEF:update_logging_config:Function]
|
|
|
|
# [DEF:ConsolidatedSettingsResponse:Class]
|
|
class ConsolidatedSettingsResponse(BaseModel):
|
|
environments: List[dict]
|
|
connections: List[dict]
|
|
llm: dict
|
|
logging: dict
|
|
storage: dict
|
|
# [/DEF:ConsolidatedSettingsResponse:Class]
|
|
|
|
# [DEF:get_consolidated_settings:Function]
|
|
# @PURPOSE: Retrieves all settings categories in a single call
|
|
# @PRE: Config manager is available.
|
|
# @POST: Returns all consolidated settings.
|
|
# @RETURN: ConsolidatedSettingsResponse - All settings categories.
|
|
@router.get("/consolidated", response_model=ConsolidatedSettingsResponse)
|
|
async def get_consolidated_settings(
|
|
config_manager: ConfigManager = Depends(get_config_manager),
|
|
_ = Depends(has_permission("admin:settings", "READ"))
|
|
):
|
|
with belief_scope("get_consolidated_settings"):
|
|
logger.info("[get_consolidated_settings][Entry] Fetching all consolidated settings")
|
|
|
|
config = config_manager.get_config()
|
|
|
|
return ConsolidatedSettingsResponse(
|
|
environments=config.environments,
|
|
connections=config.settings.connections,
|
|
llm=config.settings.llm,
|
|
logging=config.settings.logging,
|
|
storage=config.settings.storage
|
|
)
|
|
# [/DEF:get_consolidated_settings:Function]
|
|
|
|
# [/DEF:SettingsRouter:Module]
|