more fixes

backend/scripts/backup.py

@@ -5,66 +5,67 @@ import subprocess
 import datetime
 import sqlite3
 from pathlib import Path
-
 from huggingface_hub import HfApi, hf_hub_download, CommitOperationAdd
 
-# ------------------------------------------------------------------------------
-# 1. Define directories outside of /app to avoid read-only file system issues
-# ------------------------------------------------------------------------------
-BACKUP_DIR = "/tmp/open_webui/db_backup"
-DATA_DIR = "/tmp/open_webui/data"
+###############################################################################
+# 1) Determine where the *actual* database file lives
+#    - We read DATA_DIR from the environment, defaulting to "/app/backend/data"
+#    - Then the DB is "webui.db" in that directory.
+###############################################################################
+DATA_DIR = os.environ.get("DATA_DIR", "/app/backend/data")
+DB_FILE_PATH = os.path.join(DATA_DIR, "webui.db")
 
-# Actual files on the local (runtime) filesystem
+###############################################################################
+# 2) Choose a writable directory for our backup artifacts (encrypted .gpg, etc.)
+#    By default, "/tmp" is writable on Hugging Face Spaces.
+###############################################################################
+BACKUP_DIR = "/tmp/open_webui/db_backup"
 TIMESTAMP_FILE_PATH = os.path.join(BACKUP_DIR, "last_backup_time.txt")
 DB_GPG_PATH = os.path.join(BACKUP_DIR, "webui.db.gpg")
-DB_FILE_PATH = os.path.join(DATA_DIR, "webui.db")
 
-# Paths to store in the Hugging Face Space repository
-# (so your commit will look like "db_backup/webui.db.gpg" etc.)
+# Paths in the Hugging Face repo
 REPO_TIMESTAMP_FILE = "db_backup/last_backup_time.txt"
 REPO_DB_GPG_FILE = "db_backup/webui.db.gpg"
 
+
 def ensure_directories():
     """
-    Create and verify all necessary directories for our backup operation
-    in /tmp/open_webui/ rather than /app.
-    
-    Returns:
-        bool: True if directories exist and are writable
+    Create and verify the /tmp/open_webui/db_backup directory.
+    We only need to ensure the backup directory is writable, because
+    the DB itself is at DATA_DIR, which might be read-only or read-write
+    depending on your environment.
     """
     try:
-        for directory in [BACKUP_DIR, DATA_DIR]:
-            os.makedirs(directory, mode=0o755, exist_ok=True)
-            dir_stat = os.stat(directory)
-            print(f"Directory {directory} created or exists with permissions: {oct(dir_stat.st_mode)[-3:]}")
-            
-            # Verify we can write to the directory
-            test_file = os.path.join(directory, '.write_test')
-            with open(test_file, 'w') as f:
-                f.write('test')
-            os.remove(test_file)
-            print(f"Successfully verified write access to {directory}")
-            
+        os.makedirs(BACKUP_DIR, mode=0o755, exist_ok=True)
+        dir_stat = os.stat(BACKUP_DIR)
+        print(f"Backup directory {BACKUP_DIR} created or exists with permissions: {oct(dir_stat.st_mode)[-3:]}")
+        
+        # Verify we can write to this directory
+        test_file = os.path.join(BACKUP_DIR, '.write_test')
+        with open(test_file, 'w') as f:
+            f.write('test')
+        os.remove(test_file)
+        print(f"Successfully verified write access to {BACKUP_DIR}")
+        
         return True
     except Exception as e:
-        print(f"Error creating/verifying directories: {e}")
+        print(f"Error creating/verifying backup directory: {e}")
         return False
 
+
 def verify_database():
     """
-    Verify the database exists and passes a basic SQLite integrity check.
+    Ensure the actual database file exists and passes a basic SQLite integrity check.
     """
     if not os.path.exists(DB_FILE_PATH):
         print(f"Database file not found at: {DB_FILE_PATH}")
         return False
         
     try:
-        # Print file info for debugging
         file_stat = os.stat(DB_FILE_PATH)
         print(f"Database file size: {file_stat.st_size:,} bytes")
         print(f"Database file permissions: {oct(file_stat.st_mode)[-3:]}")
         
-        # Run SQLite integrity check
         with sqlite3.connect(DB_FILE_PATH) as conn:
             cursor = conn.cursor()
             cursor.execute("PRAGMA integrity_check;")
@@ -90,22 +91,20 @@ def verify_database():
         print(f"Unexpected error during verification: {e}")
         return False
 
+
 def encrypt_database(passphrase):
     """
-    Encrypt the database file using GPG (AES256), writing the .gpg file
-    to /tmp/open_webui/db_backup.
-    
-    Returns:
-        bool: True if successful, False otherwise
+    Encrypt the real DB file (DB_FILE_PATH) using GPG, outputting
+    the .gpg file to /tmp/open_webui/db_backup.
     """
     try:
         print("\nPreparing for database encryption...")
         
-        # Ensure GPG home directory is created with correct perms
+        # Ensure a GPG home directory for key storage
         gnupg_dir = '/root/.gnupg'
         os.makedirs(gnupg_dir, mode=0o700, exist_ok=True)
         
-        print("\nRunning GPG encryption...")
+        print("Running GPG encryption...")
         encrypt_cmd = [
             "gpg",
             "--batch",
@@ -139,22 +138,22 @@ def encrypt_database(passphrase):
         print(f"Encryption failed with exception: {e}")
         return False
 
+
 def get_last_backup_time(repo_id, hf_token):
     """
-    Fetch last backup timestamp from the Hugging Face Space.
-    
-    Returns:
-        datetime or None
+    Fetch last backup timestamp from the Hugging Face Space (if present).
     """
     try:
         api = HfApi()
-        files = api.list_repo_files(repo_id=repo_id, repo_type="space", token=hf_token)
-        
+        files = api.list_repo_files(
+            repo_id=repo_id, 
+            repo_type="space", 
+            token=hf_token
+        )
         if REPO_TIMESTAMP_FILE not in files:
             print("No timestamp file found in repository")
             return None
         
-        # Download the timestamp file
         temp_file = hf_hub_download(
             repo_id=repo_id,
             repo_type="space",
@@ -169,9 +168,10 @@ def get_last_backup_time(repo_id, hf_token):
         print(f"Error getting last backup time: {e}")
         return None
 
+
 def save_timestamp_locally():
     """
-    Save the current UTC time as our local timestamp.
+    Save the current UTC time to /tmp/open_webui/db_backup/last_backup_time.txt.
     """
     try:
         now = datetime.datetime.now(datetime.timezone.utc)
@@ -187,70 +187,70 @@ def save_timestamp_locally():
         print(f"Error saving timestamp: {e}")
         return False
 
+
 def backup_db():
     """
-    Main entry point for performing a backup:
-    1. Ensure directories are writable
-    2. Check if backup is needed (threshold)
-    3. Verify DB
-    4. Encrypt DB
-    5. Save new timestamp
-    6. Upload to HF Space
+    Main backup entry point:
+      1. Validate env variables
+      2. Ensure /tmp/open_webui/db_backup is writable
+      3. Check threshold to skip if recently backed up
+      4. Verify DB
+      5. Encrypt DB
+      6. Save local timestamp
+      7. Upload .gpg + timestamp to Hugging Face
     """
     passphrase = os.environ.get("BACKUP_PASSPHRASE")
     hf_token = os.environ.get("HF_TOKEN")
     space_id = os.environ.get("SPACE_ID")
     
     if not all([passphrase, hf_token, space_id]):
-        print("Error: Missing one of BACKUP_PASSPHRASE, HF_TOKEN, SPACE_ID")
+        print("Error: Missing required environment variables for backup (BACKUP_PASSPHRASE, HF_TOKEN, SPACE_ID).")
         return False
     
     if not ensure_directories():
-        print("Failed to create or verify directories")
+        print("Failed to create or verify backup directories.")
         return False
     
+    # Check threshold
     threshold_minutes = int(os.environ.get("BACKUP_THRESHOLD_MINUTES", 120))
     if threshold_minutes > 0:
         last_backup_dt = get_last_backup_time(space_id, hf_token)
         if last_backup_dt is not None:
             now = datetime.datetime.now(datetime.timezone.utc)
-            # ensure last_backup_dt has a tz
             if not last_backup_dt.tzinfo:
                 last_backup_dt = last_backup_dt.replace(tzinfo=datetime.timezone.utc)
             elapsed = now - last_backup_dt
             if elapsed.total_seconds() < threshold_minutes * 60:
                 print(f"Last backup was only {elapsed.total_seconds()/3600:.2f} hours ago")
                 print(f"Threshold is {threshold_minutes} minutes")
-                print("Skipping backup to avoid rebuilding too often")
+                print("Skipping backup to avoid frequent rebuilds")
                 return True
     else:
-        print("Backup threshold check disabled for testing")
+        print("Backup threshold check disabled (BACKUP_THRESHOLD_MINUTES=0).")
     
-    # Verify the local database
+    # Verify local DB
     if not verify_database():
-        print("Database verification failed, aborting backup")
+        print("Database verification failed, aborting backup.")
         return False
     
-    # Encrypt the database
+    # Encrypt the DB
     if not encrypt_database(passphrase):
-        print("Database encryption failed, aborting backup")
+        print("Database encryption failed, aborting backup.")
         return False
     
-    # Save timestamp to local file
+    # Save local timestamp
     if not save_timestamp_locally():
-        print("Failed to save timestamp locally, but continuing to upload anyway...")
+        print("Warning: Failed to save timestamp locally, but continuing to upload.")
     
     # Upload to Hugging Face
     print("\nUploading to Hugging Face Spaces...")
     try:
         api = HfApi()
         operations = [
-            # Add the .gpg file
             CommitOperationAdd(
                 path_in_repo=REPO_DB_GPG_FILE,
                 path_or_fileobj=DB_GPG_PATH
             ),
-            # Add the timestamp file
             CommitOperationAdd(
                 path_in_repo=REPO_TIMESTAMP_FILE,
                 path_or_fileobj=TIMESTAMP_FILE_PATH
@@ -267,9 +267,10 @@ def backup_db():
         print("Backup files uploaded successfully!")
         return True
     except Exception as e:
-        print(f"Error uploading to Hugging Face: {e}")
+        print(f"Error uploading backup to HuggingFace: {e}")
         return False
 
+
 if __name__ == "__main__":
     success = backup_db()
     sys.exit(0 if success else 1)