more fixes

backend/scripts/restore.py

@@ -7,13 +7,18 @@ from pathlib import Path
 from huggingface_hub import HfApi, hf_hub_download
 
 # Keep paths consistent with backup.py for better maintainability
+# Using relative paths allows the script to work regardless of where the repository is cloned
 TIMESTAMP_FILE_PATH = "db_backup/last_backup_time.txt"
 DB_GPG_PATH = "db_backup/webui.db.gpg"
 DB_FILE_PATH = "data/webui.db"
 
 def check_requirements():
     """
-    Check if GPG is installed and available.
+    Verify that GPG is installed and available in the system.
+    GPG is essential for decrypting the database backup.
+    
+    Returns:
+        bool: True if GPG is available, False otherwise
     """
     try:
         subprocess.run(["gpg", "--version"], check=True, capture_output=True)
@@ -24,8 +29,11 @@ def check_requirements():
 
 def validate_secrets():
     """
-    Ensure all required environment variables are set.
-    Returns False if any required variable is missing.
+    Check that all required environment variables are set.
+    These variables are essential for accessing the backup and decrypting it.
+    
+    Returns:
+        bool: True if all required variables are set, False otherwise
     """
     required_vars = ["BACKUP_PASSPHRASE", "HF_TOKEN", "SPACE_ID"]
     missing = [var for var in required_vars if not os.environ.get(var)]
@@ -35,10 +43,38 @@ def validate_secrets():
         return False
     return True
 
+def validate_repo_access(repo_id, token):
+    """
+    Verify that we can access the HuggingFace repository with the provided credentials.
+    This early check helps prevent cryptic errors later in the process.
+    
+    Args:
+        repo_id (str): The HuggingFace Space ID
+        token (str): The HuggingFace API token
+    
+    Returns:
+        bool: True if repository access is confirmed, False otherwise
+    """
+    api = HfApi()
+    try:
+        api.list_repo_files(
+            repo_id=repo_id,
+            repo_type="space",
+            token=token
+        )
+        return True
+    except Exception as e:
+        print(f"Error validating repository access: {e}")
+        print(f"Please verify your SPACE_ID ({repo_id}) and HF_TOKEN are correct")
+        return False
+
 def ensure_directories():
     """
-    Create necessary directories for database and backup files.
-    Uses relative paths consistent with backup.py.
+    Create the necessary directory structure for database and backup files.
+    This ensures we have proper permissions and all required directories exist.
+    
+    Returns:
+        bool: True if directories are created successfully, False otherwise
     """
     try:
         for directory in ["data", "db_backup"]:
@@ -50,20 +86,32 @@ def ensure_directories():
 
 def get_latest_backup_info(repo_id, hf_token):
     """
-    Retrieve information about the latest backup from Hugging Face.
-    Returns a tuple of (backup_exists, timestamp) where timestamp might be None.
+    Check for and retrieve information about the latest backup from HuggingFace.
+    This function both verifies backup existence and gets its timestamp.
+    
+    Args:
+        repo_id (str): The HuggingFace Space ID
+        hf_token (str): The HuggingFace API token
+    
+    Returns:
+        tuple: (backup_exists: bool, timestamp: datetime or None)
     """
     api = HfApi()
     try:
         # First check if the backup file exists in the repository
-        files = api.list_files_info(repo_id=repo_id, repo_type="space", token=hf_token)
-        backup_exists = any(file.rfilename == DB_GPG_PATH for file in files)
+        files = api.list_repo_files(
+            repo_id=repo_id,
+            repo_type="space",
+            token=hf_token
+        )
+        
+        backup_exists = DB_GPG_PATH in files
         
         if not backup_exists:
             print("No backup file found in the repository")
             return False, None
             
-        # Try to get the timestamp information
+        # If backup exists, try to get its timestamp
         try:
             timestamp_file = hf_hub_download(
                 repo_id=repo_id,
@@ -83,12 +131,25 @@ def get_latest_backup_info(repo_id, hf_token):
             
     except Exception as e:
         print(f"Error checking repository: {e}")
+        print("For debugging - trying to list repository contents:")
+        try:
+            files = api.list_repo_files(repo_id=repo_id, repo_type="space", token=hf_token)
+            print(f"Files in repository: {files}")
+        except Exception as debug_e:
+            print(f"Debug listing failed: {debug_e}")
         return False, None
 
 def download_backup(repo_id, hf_token):
     """
-    Download the encrypted database backup from Hugging Face.
-    Returns True if successful, False otherwise.
+    Download the encrypted database backup from HuggingFace.
+    Handles the safe download and placement of the backup file.
+    
+    Args:
+        repo_id (str): The HuggingFace Space ID
+        hf_token (str): The HuggingFace API token
+    
+    Returns:
+        bool: True if download is successful, False otherwise
     """
     try:
         print("Downloading encrypted database backup...")
@@ -111,8 +172,13 @@ def download_backup(repo_id, hf_token):
 
 def decrypt_database(passphrase):
     """
-    Decrypt the database file using GPG.
-    Returns True if successful or if no backup exists (first run).
+    Decrypt the downloaded database file using GPG.
+    
+    Args:
+        passphrase (str): The passphrase for decrypting the database
+    
+    Returns:
+        bool: True if decryption is successful or no backup exists, False on error
     """
     if not os.path.exists(DB_GPG_PATH):
         print("No encrypted backup found locally")
@@ -141,8 +207,10 @@ def decrypt_database(passphrase):
 
 def verify_database():
     """
-    Verify the integrity of the restored database.
-    Returns True if the database is valid or doesn't exist.
+    Verify the integrity of the restored database using SQLite's built-in checks.
+    
+    Returns:
+        bool: True if database is valid or doesn't exist, False if corrupted
     """
     if not os.path.exists(DB_FILE_PATH):
         return True  # Not an error, might be first run
@@ -165,8 +233,11 @@ def verify_database():
 
 def restore_db():
     """
-    Main function to handle the database restoration process.
-    Downloads the latest backup from Hugging Face and restores it.
+    Main function that orchestrates the database restoration process.
+    Performs all necessary checks and handles the complete restore operation.
+    
+    Returns:
+        bool: True if restore is successful or no backup needed, False on error
     """
     # Check requirements and environment
     if not check_requirements() or not validate_secrets():
@@ -181,6 +252,10 @@ def restore_db():
     hf_token = os.environ["HF_TOKEN"]
     space_id = os.environ["SPACE_ID"]
     
+    # Validate repository access first
+    if not validate_repo_access(space_id, hf_token):
+        return False
+    
     # Check if there's a backup in the repository
     backup_exists, timestamp = get_latest_backup_info(space_id, hf_token)
     

backend/start.sh

@@ -1,7 +1,39 @@
 #!/usr/bin/env bash
 
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd "$SCRIPT_DIR" || exit
+SCRIPT_PATH=$(readlink -f "${BASH_SOURCE[0]}")
+SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
+ORIGINAL_DIR=$(pwd)
+
+log_message() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
+}
+
+validate_environment() {
+    # Check if we're in the expected container directory structure
+    if [[ "$(pwd)" != *"/app/backend" ]]; then
+        log_message "Warning: Unexpected working directory: $(pwd)"
+        log_message "Expected path to contain: /app/backend"
+        return 1
+    fi
+    return 0
+}
+
+log_message "Changing to script directory: $SCRIPT_DIR"
+cd "$SCRIPT_DIR" || {
+    log_message "Error: Could not change to directory: $SCRIPT_DIR"
+    exit 1
+}
+
+validate_environment || {
+    log_message "Warning: Environment validation failed, but continuing..."
+}
+
+log_message "Working from directory: $(pwd)"
+
+SCRIPTS_DIR="$SCRIPT_DIR/scripts"
+DATA_DIR="$SCRIPT_DIR/data"
+BACKUP_DIR="$SCRIPT_DIR/db_backup"
+
 
 # Validate required environment variables for backup/restore operations
 for var in "BACKUP_PASSPHRASE" "HF_TOKEN" "SPACE_ID"; do
@@ -11,35 +43,44 @@ for var in "BACKUP_PASSPHRASE" "HF_TOKEN" "SPACE_ID"; do
     fi
 done
 
-# Restore database from backup
-echo "Restoring database from backup..."
-python scripts/restore.py
+# Restore database from backup using absolute path
+log_message "Restoring database from backup..."
+python "$SCRIPTS_DIR/restore.py"
 restore_status=$?
 if [ $restore_status -ne 0 ]; then
-    echo "Warning: Database restore failed. Starting with empty database."
+    log_message "Warning: Database restore failed. Starting with empty database."
 fi
 
 # Handle WebUI secret key generation/loading
-KEY_FILE=.webui_secret_key
+KEY_FILE="$SCRIPT_DIR/.webui_secret_key"
 PORT="${PORT:-8080}"
 HOST="${HOST:-0.0.0.0}"
+
 if test "$WEBUI_SECRET_KEY $WEBUI_JWT_SECRET_KEY" = " "; then
-    echo "Loading WEBUI_SECRET_KEY from file, not provided as an environment variable."
+    log_message "Loading WEBUI_SECRET_KEY from file, not provided as an environment variable."
     if ! [ -e "$KEY_FILE" ]; then
-        echo "Generating WEBUI_SECRET_KEY"
-        echo $(head -c 12 /dev/random | base64) > "$KEY_FILE"
+        log_message "Generating WEBUI_SECRET_KEY"
+        head -c 12 /dev/random | base64 > "$KEY_FILE" || {
+            log_message "Error: Could not generate secret key"
+            exit 1
+        }
     fi
-    echo "Loading WEBUI_SECRET_KEY from $KEY_FILE"
-    WEBUI_SECRET_KEY=$(cat "$KEY_FILE")
+    log_message "Loading WEBUI_SECRET_KEY from $KEY_FILE"
+    WEBUI_SECRET_KEY=$(cat "$KEY_FILE") || {
+        log_message "Error: Could not read secret key"
+        exit 1
+    }
 fi
 
+# Handle Ollama configuration if enabled
 if [[ "${USE_OLLAMA_DOCKER,,}" == "true" ]]; then
-    echo "USE_OLLAMA is set to true, starting ollama serve."
+    log_message "USE_OLLAMA is set to true, starting ollama serve."
     ollama serve &
 fi
 
+# Configure CUDA environment if enabled
 if [[ "${USE_CUDA_DOCKER,,}" == "true" ]]; then
-    echo "CUDA is enabled, appending LD_LIBRARY_PATH to include torch/cudnn & cublas libraries."
+    log_message "CUDA is enabled, configuring LD_LIBRARY_PATH"
     export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/lib/python3.11/site-packages/torch/lib:/usr/local/lib/python3.11/site-packages/nvidia/cudnn/lib"
 fi
 
@@ -67,27 +108,37 @@ if [ -n "$SPACE_ID" ]; then
 fi
 
 # Launch the main web server in the background
+log_message "Starting main web server..."
 WEBUI_SECRET_KEY="$WEBUI_SECRET_KEY" uvicorn open_webui.main:app \
     --host "$HOST" --port "$PORT" --forwarded-allow-ips '*' &
 WEBUI_PID=$!
 
-# Configure backup schedule
+# Configure backup schedule with environment variable defaults
 BACKUP_INITIAL_WAIT="${BACKUP_INITIAL_WAIT:-500}"  # Default to 500 seconds
-BACKUP_INTERVAL="${BACKUP_INTERVAL:-21600}"        # Default to 6 hours (21600 seconds)
+BACKUP_INTERVAL="${BACKUP_INTERVAL:-21600}"        # Default to 6 hours
 
 # Start the background backup job
 (
-    echo "Waiting ${BACKUP_INITIAL_WAIT} seconds before starting backup schedule..."
+    log_message "Starting backup scheduler"
+    log_message "Initial wait: ${BACKUP_INITIAL_WAIT}s, Interval: ${BACKUP_INTERVAL}s"
+    
     sleep "$BACKUP_INITIAL_WAIT"
 
     while true; do
-        echo "==============================================="
-        echo "Running scheduled backup job"
-        echo "==============================================="
-        # Allow threshold override for testing
-        BACKUP_THRESHOLD_MINUTES="${BACKUP_THRESHOLD_MINUTES:-120}" python "$SCRIPT_DIR/backup.py"
+        log_message "=== Starting scheduled backup ==="
+        
+        # Run backup script with absolute path
+        BACKUP_THRESHOLD_MINUTES="${BACKUP_THRESHOLD_MINUTES:-120}" \
+            python "$SCRIPTS_DIR/backup.py"
+        
+        backup_status=$?
+        if [ $backup_status -ne 0 ]; then
+            log_message "Warning: Backup failed with status $backup_status"
+        else
+            log_message "Backup completed successfully"
+        fi
         
-        echo "Waiting ${BACKUP_INTERVAL} seconds until next backup..."
+        log_message "Waiting ${BACKUP_INTERVAL} seconds until next backup..."
         sleep "$BACKUP_INTERVAL"
     done
 ) &