🔍 Code Extractor

Initializes the CDocs document management system by setting up database connections, FileCloud integration, document sharing validation, and API routes.

Purpose

This function serves as the main initialization routine for the CDocs system. It orchestrates the startup sequence by initializing critical components including database connections, FileCloud integration for file storage, document sharing permission validation, and API route registration. It provides comprehensive error handling and returns detailed results about the initialization status of each component, making it suitable for system startup diagnostics and health checks.

Source Code

def initialize_system(validate_sharing: bool = True) -> Dict[str, Any]:
    """
    Initialize the CDocs system.
    
    Parameters
    ----------
    validate_sharing : bool, optional
        Whether to validate document sharing permissions (default: True)
        
    Returns
    -------
    Dict[str, Any]
        Initialization results
    """
    start_time = datetime.now()
    logger.info("Starting CDocs system initialization")
    
    results = {
        "success": True,
        "start_time": start_time.isoformat(),
        "components": {},
        "errors": []
    }
    
    # Initialize database connections if needed
    try:
        from CDocs import db
        logger.info("Database connection initialized")
        results["components"]["database"] = {"success": True}
    except Exception as e:
        logger.error(f"Error initializing database connection: {e}")
        results["components"]["database"] = {"success": False, "error": str(e)}
        results["errors"].append(f"Database initialization error: {e}")
        results["success"] = False
    
    # Check if FileCloud integration is configured
    try:
        from CDocs.controllers.filecloud_controller import get_filecloud_client
        fc_client = get_filecloud_client()
        if fc_client:
            logger.info("FileCloud integration initialized")
            results["components"]["filecloud"] = {"success": True}
        else:
            logger.warning("FileCloud client not available")
            results["components"]["filecloud"] = {
                "success": False, 
                "warning": "FileCloud client not available"
            }
    except Exception as e:
        logger.error(f"Error initializing FileCloud integration: {e}")
        results["components"]["filecloud"] = {"success": False, "error": str(e)}
        results["errors"].append(f"FileCloud initialization error: {e}")
    
    # Validate document sharing permissions if enabled
    if validate_sharing:
        try:
            from CDocs.controllers.permission_startup_check import run_permission_check_async
            logger.info("Validating document sharing permissions...")
            sharing_results = run_permission_check_async()
            
            logger.info("Document sharing validation started in background")
            results["components"]["sharing_validation"] = {
                "success": True,
                "background": True,
                "message": "Permission check running in background"
            }
        except Exception as e:
            logger.error(f"Error during document sharing validation: {e}")
            results["components"]["sharing_validation"] = {"success": False, "error": str(e)}
            results["errors"].append(f"Sharing validation error: {e}")
    
    # Register API routes
    try:
        from CDocs.controllers.api_handler import register_api_routes
        logger.info("Registering API routes...")
        register_api_routes()
        results["components"]["api_routes"] = {"success": True}
    except Exception as e:
        logger.error(f"Error registering API routes: {e}")
        results["components"]["api_routes"] = {"success": False, "error": str(e)}
        results["errors"].append(f"API routes registration error: {e}")
    
    # Calculate total initialization time
    end_time = datetime.now()
    duration = (end_time - start_time).total_seconds()
    results["end_time"] = end_time.isoformat()
    results["duration_seconds"] = duration
    
    if results["success"]:
        logger.info(f"CDocs system initialization completed successfully in {duration:.2f} seconds")
    else:
        logger.warning(f"CDocs system initialization completed with errors in {duration:.2f} seconds")
        
    return results

Parameters

Parameter Details

validate_sharing: Boolean flag that controls whether document sharing permissions should be validated during initialization. When True (default), the function runs an asynchronous permission check in the background to validate document sharing configurations. Set to False to skip this validation, which may be useful for faster startup in development environments or when permission validation is not required.

Return Value

Type: Dict[str, Any]

Returns a dictionary containing comprehensive initialization results. The dictionary includes: 'success' (bool) indicating overall initialization success, 'start_time' and 'end_time' (ISO format strings) marking initialization timestamps, 'duration_seconds' (float) showing total initialization time, 'components' (dict) with status of each initialized component (database, filecloud, sharing_validation, api_routes), and 'errors' (list) containing any error messages encountered during initialization. Each component entry contains at minimum a 'success' boolean, and may include 'error', 'warning', or other status information.

Dependencies

• logging
• datetime
• typing
• CDocs

Required Imports

from typing import Dict, Any
from datetime import datetime
import logging

Conditional/Optional Imports

These imports are only needed under specific conditions:

from CDocs import db

from CDocs.controllers.filecloud_controller import get_filecloud_client

from CDocs.controllers.permission_startup_check import run_permission_check_async

from CDocs.controllers.api_handler import register_api_routes

Usage Example

from datetime import datetime
from typing import Dict, Any
import logging

# Setup logger (assumed to be in module scope)
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# Initialize system with all validations
results = initialize_system(validate_sharing=True)

if results['success']:
    print(f"System initialized successfully in {results['duration_seconds']:.2f} seconds")
    print(f"Components initialized: {list(results['components'].keys())}")
else:
    print(f"Initialization completed with errors: {results['errors']}")
    for component, status in results['components'].items():
        if not status.get('success', False):
            print(f"  - {component}: {status.get('error', 'Unknown error')}")

# Initialize without sharing validation for faster startup
quick_results = initialize_system(validate_sharing=False)
print(f"Quick initialization completed: {quick_results['success']}")

Best Practices

• Always check the 'success' field in the returned dictionary before proceeding with system operations
• Review the 'errors' list to diagnose any initialization failures
• Set validate_sharing=False during development or testing to speed up initialization if permission validation is not needed
• Ensure the logger is properly configured before calling this function as it relies on module-level logger variable
• Monitor the 'duration_seconds' field to track initialization performance over time
• Handle partial initialization gracefully - some components may fail while others succeed
• The sharing validation runs asynchronously in the background, so it won't block the initialization process
• Consider implementing retry logic for critical components that fail during initialization
• Store initialization results for debugging and system health monitoring purposes

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function init 67.3% similar

  Wrapper function that initializes the CDocs system by calling initialize_system() when the module is imported.

  From: /tf/active/vicechatdev/CDocs/initialize_system.py

• function check_document_permissions_on_startup_v1 66.5% similar

  Performs a system-wide startup check to verify and update document permissions for all documents in the system, ensuring permissions align with document status.

  From: /tf/active/vicechatdev/CDocs/controllers/permission_startup_check.py

• function check_document_permissions_on_startup 61.8% similar

  Validates and fixes document permission issues during application startup, prioritizing active documents (DRAFT, IN_REVIEW, IN_APPROVAL) to ensure proper sharing permissions are configured.

  From: /tf/active/vicechatdev/CDocs/utils/sharing_validator.py

• function ensure_document_version_share_attributes 54.0% similar

  Ensures a DocumentVersion object has share_id and share_url attributes, initializing them to None if missing and persisting changes to the database.

  From: /tf/active/vicechatdev/CDocs/controllers/permission_startup_check.py

• function manage_user_share_access_v2 52.0% similar

  Manages user access permissions to a FileCloud document share, creating shares if needed and setting read-only or write access for specified users.

  From: /tf/active/vicechatdev/CDocs/controllers/permission_startup_check.py