Update sync_data.sh

sync_data.sh

@@ -1,336 +1,331 @@
 #!/bin/bash
 
+# --- Helper Functions ---
+
 # Function to check if Cloudreve is running by checking the port
 wait_for_cloudreve() {
-    echo "Waiting for Cloudreve service to become available on port 5212..."
-    # Loop until nc successfully connects (-z checks without sending data)
+    echo "[Backup Manager] Waiting for Cloudreve service (port 5212)..."
     while ! nc -z 127.0.0.1 5212; do
-        echo "Cloudreve not ready yet (port 5212 not open), sleeping for 5 seconds..."
+        echo "[Backup Manager] Cloudreve not ready yet, sleeping 5s..."
         sleep 5
     done
-    echo "Cloudreve service detected on port 5212."
+    echo "[Backup Manager] Cloudreve service detected."
 }
 
 # Function to perform a single backup action
 perform_backup_once() {
-    echo "Performing single backup operation..."
+    echo "[Backup Action] Performing single backup..."
     local config_path="$1"
     local db_path="$2"
     local exe_path="$3"
     local cloudreve_dir="$4"
     local backup_prefix="$5"
 
+    # Wait brief moment to ensure files are stable after service start
+    sleep 5
+
     if [ ! -f "$config_path" ] || [ ! -f "$db_path" ] || [ ! -f "$exe_path" ]; then
-         echo "WARN: Essential files missing for backup. Skipping this backup."
+         echo "[Backup Action] WARN: Essential files missing for backup ($config_path, $db_path, $exe_path). Skipping."
          return 1
     fi
 
     local timestamp=$(date +%Y%m%d_%H%M%S)
     local backup_file="${backup_prefix}_${timestamp}.tar.gz"
-    local backup_path="/tmp/${backup_file}" # Use /tmp for temporary files
+    local backup_path="/tmp/${backup_file}"
 
-    echo "Compressing Cloudreve data (executable, db, config) to: $backup_path"
+    echo "[Backup Action] Compressing data (exec, db, config) to: $backup_path"
     tar -czf "$backup_path" -C "$cloudreve_dir" \
-        $(basename "$exe_path") \
-        $(basename "$db_path") \
-        $(basename "$config_path")
+        "$(basename "$exe_path")" \
+        "$(basename "$db_path")" \
+        "$(basename "$config_path")" \
+        || { echo "[Backup Action] ERROR: tar command failed."; rm -f "$backup_path"; return 1; } # Add error check
 
     if [ -s "$backup_path" ]; then
-        echo "Compression complete. File size: $(ls -lh "$backup_path" | awk '{print $5}')"
-        echo "Uploading backup to HuggingFace..."
-        # Call the previously defined upload_backup function
+        echo "[Backup Action] Compression complete. Size: $(ls -lh "$backup_path" | awk '{print $5}')"
+        echo "[Backup Action] Uploading backup to HuggingFace..."
+        # Call the Python upload_backup function
         upload_backup "$backup_path" "${backup_file}"
         local upload_status=$?
         if [ $upload_status -ne 0 ]; then
-            echo "Backup upload failed. Keeping local archive: $backup_path"
+            echo "[Backup Action] ERROR: Backup upload failed. Keeping local archive: $backup_path"
             return 1
         else
-            echo "Upload successful. Removing local archive."
+            echo "[Backup Action] Upload successful. Removing local archive."
             rm -f "$backup_path"
             return 0
         fi
     else
-        echo "Compression failed or created an empty file. Skipping upload."
-        rm -f "$backup_path" # Remove potentially empty/corrupt file
+        echo "[Backup Action] ERROR: Compression failed or created empty file. Skipping upload."
+        rm -f "$backup_path"
         return 1
     fi
 }
 
-
-# --- Start Script Execution ---
-
-# Check Hugging Face Token and Dataset ID environment variables
-if [[ -z "$HF_TOKEN" ]] || [[ -z "$DATASET_ID" ]]; then
-    echo "Starting without backup functionality - missing HF_TOKEN or DATASET_ID"
-    # Ensure Aria2 starts if needed, even without backup/restore
-    # Example (adjust options as needed from your Dockerfile CMD):
-    # aria2c --daemon=true [OTHER_OPTIONS] &
-    exec /opt/cloudreve/cloudreve -c /opt/cloudreve/config.ini
-    exit 0
-fi
-
-# Activate Python virtual environment
-echo "Activating Python venv..."
-source /opt/venv/bin/activate
-
-# Define Cloudreve paths and backup prefix
-CLOUDREVE_DIR="/opt/cloudreve"
-BACKUP_PREFIX="cloudreve_backup"
-CONFIG_FILE_PATH="/opt/cloudreve/config.ini"
-DB_FILE_PATH="/opt/cloudreve/cloudreve.db"
-EXECUTABLE_PATH="/opt/cloudreve/cloudreve"
-
-
-# --- Python Function Definitions (Ensure these are complete) ---
+# --- Python Function Definitions (Ensure these are complete and correct) ---
 
 # Python Function: Upload Backup
 upload_backup() {
-    local file_path="$1"
-    local file_name="$2"
-    local token="$HF_TOKEN"
-    local repo_id="$DATASET_ID"
-
-    echo "Preparing to upload backup file: $file_path as $file_name to Dataset: $repo_id"
-
-    # Use python3 -c "..." with the full Python code block here
-    # (Using placeholder for brevity, replace with your actual Python code)
+    local file_path="$1"; local file_name="$2"; local token="$HF_TOKEN"; local repo_id="$DATASET_ID"
+    echo "[Python Upload] Preparing: $file_path as $file_name to $repo_id"
     python3 -c "
-from huggingface_hub import HfApi
-import sys, os
-print(f'HF_TOKEN is set: {os.environ.get(\"HF_TOKEN\") is not None}')
-print(f'DATASET_ID is set: {os.environ.get(\"DATASET_ID\") is not None}')
-def manage_backups(api, repo_id_val, max_files=50): # Increased max_files
-    print('Managing old backups...')
+import sys, os, time
+from huggingface_hub import HfApi, list_repo_files, delete_file, upload_file
+print(f'[Python Upload] HF_TOKEN is set: {os.environ.get(\"HF_TOKEN\") is not None}')
+print(f'[Python Upload] DATASET_ID is set: {os.environ.get(\"DATASET_ID\") is not None}')
+
+def manage_backups(api, repo_id_val, backup_prefix_val, max_files=50): # Increased max_files
+    print('[Python Upload] Managing old backups...')
     try:
-        files = api.list_repo_files(repo_id=repo_id_val, repo_type='dataset')
-        backup_files = sorted([f for f in files if f.startswith('$BACKUP_PREFIX') and f.endswith('.tar.gz')])
+        # Retry logic for listing files, as sometimes HF API might be slow/flaky
+        for attempt in range(3):
+            try:
+                files = list_repo_files(repo_id=repo_id_val, repo_type='dataset', token=os.environ.get('HF_TOKEN'))
+                break # Success
+            except Exception as list_err:
+                print(f'[Python Upload] Error listing files (attempt {attempt+1}/3): {list_err}')
+                if attempt == 2: raise # Raise after last attempt
+                time.sleep(5) # Wait before retrying
+
+        backup_files = sorted([f for f in files if f.startswith(backup_prefix_val) and f.endswith('.tar.gz')])
+        print(f'[Python Upload] Found {len(backup_files)} existing backup files.')
         if len(backup_files) >= max_files:
-            print(f'Found {len(backup_files)} backup files, maximum allowed is {max_files}.')
-            files_to_delete = backup_files[:len(backup_files) - max_files + 1]
-            print(f'Will delete {len(files_to_delete)} old backups.')
+            num_to_delete = len(backup_files) - max_files + 1
+            print(f'[Python Upload] Max backups ({max_files}) reached. Need to delete {num_to_delete} oldest backups.')
+            files_to_delete = backup_files[:num_to_delete]
             for file_to_delete in files_to_delete:
                 try:
-                    print(f'Deleting old backup: {file_to_delete}')
-                    api.delete_file(path_in_repo=file_to_delete, repo_id=repo_id_val, repo_type='dataset', token=os.environ.get('HF_TOKEN'))
-                    print(f'Successfully deleted: {file_to_delete}')
+                    print(f'[Python Upload] Deleting old backup: {file_to_delete}')
+                    delete_file(path_in_repo=file_to_delete, repo_id=repo_id_val, repo_type='dataset', token=os.environ.get('HF_TOKEN'))
+                    print(f'[Python Upload] Successfully deleted: {file_to_delete}')
                 except Exception as e:
-                    print(f'Error deleting {file_to_delete}: {str(e)}')
+                    print(f'[Python Upload] ERROR deleting {file_to_delete}: {str(e)}') # Log error but continue
         else:
-            print(f'Number of backup files ({len(backup_files)}) is within the limit ({max_files}).')
+            print(f'[Python Upload] Number of backups ({len(backup_files)}) is within the limit ({max_files}).')
     except Exception as e:
-        print(f'Error listing or managing backups: {e}')
+        print(f'[Python Upload] ERROR during backup management: {e}')
 
 api = HfApi(token='$token')
+repo_id_val = os.environ.get('DATASET_ID')
+file_path_val = '$file_path'
+file_name_val = '$file_name'
+backup_prefix_val = '$BACKUP_PREFIX' # Pass prefix correctly
+
+if not repo_id_val: print('[Python Upload] ERROR: DATASET_ID missing.'); sys.exit(1)
+if not os.path.exists(file_path_val): print(f'[Python Upload] ERROR: Backup file {file_path_val} not found.'); sys.exit(1)
+
 try:
-    repo_id_val = os.environ.get('DATASET_ID')
-    if not repo_id_val: raise ValueError('DATASET_ID environment variable is not set.')
-    print(f'Uploading file: $file_path to {repo_id_val} as $file_name')
-    api.upload_file(path_or_fileobj='$file_path', path_in_repo='$file_name', repo_id=repo_id_val, repo_type='dataset', token=os.environ.get('HF_TOKEN'))
-    print(f'Successfully uploaded $file_name')
-    manage_backups(api, repo_id_val)
+    print(f'[Python Upload] Uploading: {file_path_val} to {repo_id_val} as {file_name_val}')
+    upload_file(
+        path_or_fileobj=file_path_val,
+        path_in_repo=file_name_val,
+        repo_id=repo_id_val,
+        repo_type='dataset',
+        token=os.environ.get('HF_TOKEN') # Explicitly pass token
+    )
+    print(f'[Python Upload] Successfully uploaded {file_name_val}')
+    manage_backups(api, repo_id_val, backup_prefix_val) # Pass prefix
 except Exception as e:
-    print(f'Error uploading file: {str(e)}')
+    import traceback
+    print(f'[Python Upload] ERROR uploading file: {str(e)}')
+    # traceback.print_exc() # Uncomment for full traceback if needed
     sys.exit(1) # Indicate failure
 "
-    # Capture python exit code
-    return $?
+    return $? # Return python exit code
 }
 
 # Python Function: Download Latest Backup
 download_latest_backup() {
-    local token="$HF_TOKEN"
-    local repo_id="$DATASET_ID"
+    local token="$HF_TOKEN"; local repo_id="$DATASET_ID"
     local download_flag_file="/tmp/backup_restored.flag" # Flag file
+    rm -f "$download_flag_file" # Ensure flag is removed initially
+    echo "[Python Restore] Preparing to download from Dataset: $repo_id"
 
-    # Remove any previous flag file
-    rm -f "$download_flag_file"
-
-    echo "Preparing to download the latest backup from Dataset: $repo_id"
-
-    # Use python3 -c "..." with the full Python code block here
-    # (Using placeholder for brevity, replace with your actual Python code)
     python3 -c "
-from huggingface_hub import HfApi, hf_hub_download
-import sys, os, tarfile, tempfile, shutil, subprocess
-print(f'HF_TOKEN is set: {os.environ.get(\"HF_TOKEN\") is not None}')
-print(f'DATASET_ID is set: {os.environ.get(\"DATASET_ID\") is not None}')
-flag_file = '$download_flag_file' # Get flag file path
+import sys, os, tarfile, tempfile, shutil, subprocess, time
+from huggingface_hub import HfApi, hf_hub_download, list_repo_files
+print(f'[Python Restore] HF_TOKEN is set: {os.environ.get(\"HF_TOKEN\") is not None}')
+print(f'[Python Restore] DATASET_ID is set: {os.environ.get(\"DATASET_ID\") is not None}')
+flag_file = '$download_flag_file'
 
 api = HfApi(token='$token')
+repo_id_val = os.environ.get('DATASET_ID')
+if not repo_id_val: print('[Python Restore] ERROR: DATASET_ID missing.'); sys.exit(1)
+
 try:
-    repo_id_val = os.environ.get('DATASET_ID')
-    if not repo_id_val: raise ValueError('DATASET_ID environment variable is not set.')
+    print(f'[Python Restore] Listing files in Dataset: {repo_id_val}')
+    # Retry logic for listing files
+    for attempt in range(3):
+        try:
+            files = list_repo_files(repo_id=repo_id_val, repo_type='dataset', token=os.environ.get('HF_TOKEN'))
+            break # Success
+        except Exception as list_err:
+            print(f'[Python Restore] Error listing files (attempt {attempt+1}/3): {list_err}')
+            if attempt == 2: raise
+            time.sleep(5)
 
-    print(f'Listing files in Dataset: {repo_id_val}')
-    files = api.list_repo_files(repo_id=repo_id_val, repo_type='dataset')
     backup_files = sorted([f for f in files if f.startswith('$BACKUP_PREFIX') and f.endswith('.tar.gz')])
 
     if not backup_files:
-        print('No backup files found in the Dataset. Skipping restore.')
-        sys.exit(0) # Success: No backup found is not an error for the script flow
+        print('[Python Restore] No backup files found. Skipping restore.')
+        sys.exit(0) # Success: No backup found is OK for script flow
 
     latest_backup = backup_files[-1]
-    print(f'Latest backup file found: {latest_backup}')
+    print(f'[Python Restore] Latest backup file found: {latest_backup}')
 
     with tempfile.TemporaryDirectory() as temp_dir:
-        print(f'Downloading {latest_backup} to temporary directory {temp_dir}...')
+        print(f'[Python Restore] Downloading {latest_backup} to {temp_dir}...')
         try:
             filepath = hf_hub_download(repo_id=repo_id_val, filename=latest_backup, repo_type='dataset', local_dir=temp_dir, token=os.environ.get('HF_TOKEN'))
-        except Exception as download_error:
-            print(f'Error during hf_hub_download: {download_error}'); sys.exit(1)
+        except Exception as download_error: print(f'[Python Restore] ERROR during download: {download_error}'); sys.exit(1)
 
         if filepath and os.path.exists(filepath):
-            print(f'Successfully downloaded backup to temporary directory: {filepath}')
-            items_to_restore = ['cloudreve', 'cloudreve.db', 'config.ini']
-            os.makedirs(\"$CLOUDREVE_DIR\", exist_ok=True)
-            print('Listing contents before restore:'); subprocess.run(['ls', '-lA', \"$CLOUDREVE_DIR\"], check=False)
+            print(f'[Python Restore] Download successful: {filepath}')
+            items_to_restore = ['cloudreve', 'cloudreve.db', 'config.ini'] # Files to restore
+            target_dir = os.environ.get('CLOUDREVE_DIR', '/opt/cloudreve') # Get target dir from env
+            os.makedirs(target_dir, exist_ok=True)
+            print('[Python Restore] Contents before restore:'); subprocess.run(['ls', '-lA', target_dir], check=False)
 
             extract_temp_dir = os.path.join(temp_dir, 'extracted_backup'); os.makedirs(extract_temp_dir, exist_ok=True)
-            print(f'Extracting backup archive: {filepath} to {extract_temp_dir}')
+            print(f'[Python Restore] Extracting archive to {extract_temp_dir}')
             try:
-                with tarfile.open(filepath, 'r:gz') as tar: tar.extractall(extract_temp_dir)
-                print('Extraction complete.')
-            except Exception as extract_err: print(f'Error during extraction: {extract_err}'); sys.exit(1)
+                with tarfile.open(filepath, 'r:gz') as tar: tar.extractall(path=extract_temp_dir)
+                print('[Python Restore] Extraction complete.')
+            except Exception as extract_err: print(f'[Python Restore] ERROR during extraction: {extract_err}'); sys.exit(1)
 
             essential_files_present = True
+            print(f'[Python Restore] Checking extracted items in {extract_temp_dir}:')
             for item in items_to_restore:
-                extracted_item_path = os.path.join(extract_temp_dir, item)
-                if not os.path.exists(extracted_item_path):
-                    print(f'Error: Essential item "{item}" not found in extracted backup at {extracted_item_path}. Aborting restore.')
-                    essential_files_present = False; # break # Keep checking all missing items
+                extracted_path = os.path.join(extract_temp_dir, item)
+                print(f'[Python Restore] Checking for: {extracted_path}')
+                if not os.path.exists(extracted_path):
+                    print(f'[Python Restore] ERROR: Essential item "{item}" not found in backup.'); essential_files_present = False
             if not essential_files_present:
-                 print('Listing contents of extraction directory for debugging:'); subprocess.run(['ls', '-lA', extract_temp_dir], check=False)
-                 sys.exit(1) # Abort if essential files are missing
+                 print('[Python Restore] Aborting restore due to missing essential files.'); sys.exit(1)
 
-            print(f'Deleting existing items in $CLOUDREVE_DIR before restoring...')
+            print(f'[Python Restore] Deleting existing items in {target_dir}...')
             for item in items_to_restore:
-                target_path = os.path.join(\"$CLOUDREVE_DIR\", item)
+                target_path = os.path.join(target_dir, item)
                 if os.path.exists(target_path):
                     try:
                         if os.path.isdir(target_path) and not os.path.islink(target_path): shutil.rmtree(target_path)
                         else: os.remove(target_path)
-                    except OSError as e: print(f'Error deleting {target_path}: {e}. Continuing...')
+                        print(f'[Python Restore] Deleted: {target_path}')
+                    except OSError as e: print(f'[Python Restore] Error deleting {target_path}: {e}')
 
-            print(f'Moving extracted items from {extract_temp_dir} to $CLOUDREVE_DIR...')
+            print(f'[Python Restore] Moving extracted items to {target_dir}...')
             for item in items_to_restore:
-                 source_path = os.path.join(extract_temp_dir, item)
-                 if os.path.exists(source_path):
-                     target_path = os.path.join(\"$CLOUDREVE_DIR\", item)
-                     try: shutil.move(source_path, target_path)
-                     except Exception as move_err: print(f'Error moving {item}: {move_err}') # Continue for now
-                 else: print(f'Warning: Source item {item} disappeared before move.')
-
-            print(f'Successfully restored backup from {latest_backup}')
-            print('Listing contents after restore:'); subprocess.run(['ls', '-lA', \"$CLOUDREVE_DIR\"], check=False)
-            # Create the flag file only on successful restore
-            with open(flag_file, 'w') as f: f.write('restored')
-            print(f'Created restore flag file: {flag_file}')
-            sys.exit(0) # Indicate successful restore completion
+                 source = os.path.join(extract_temp_dir, item); target = os.path.join(target_dir, item)
+                 try: shutil.move(source, target); print(f'[Python Restore] Moved: {item}')
+                 except Exception as move_err: print(f'[Python Restore] Error moving {item}: {move_err}')
+
+            print(f'[Python Restore] Successfully restored backup from {latest_backup}')
+            print('[Python Restore] Contents after restore:'); subprocess.run(['ls', '-lA', target_dir], check=False)
+            with open(flag_file, 'w') as f: f.write('restored') # Create flag file
+            print(f'[Python Restore] Created restore flag file: {flag_file}')
+            sys.exit(0) # Indicate successful restore
         else:
-            print(f'Error: Downloaded file path "{filepath}" does not exist or download failed.')
+            print(f'[Python Restore] ERROR: Downloaded file path invalid or missing: {filepath}')
             sys.exit(1)
 
-except ValueError as ve: print(f'Configuration Error: {ve}'); sys.exit(1)
-except Exception as e: import traceback; print(f'Error during backup download/restore: {str(e)}'); traceback.print_exc(); sys.exit(1)
+except Exception as e: import traceback; print(f'[Python Restore] ERROR during download/restore: {str(e)}'); traceback.print_exc(); sys.exit(1)
 "
-    # Capture python exit code
-    return $?
+    return $? # Return python exit code
 }
 
-# --- Periodic Sync Function (Loop only) ---
-sync_data_loop() {
-    echo "Starting Periodic Background Sync Loop..."
+# --- Background Backup Manager Function ---
+manage_backups_background() {
+    local restored_flag_path="$1" # Pass path to the flag file
+
+    echo "[Backup Manager] Process started. Waiting for Cloudreve..."
+    wait_for_cloudreve # Wait until Cloudreve port is open
+
+    # Determine if initial backup is needed
+    local perform_initial_backup=true
+    if [ -f "$restored_flag_path" ]; then
+        echo "[Backup Manager] Restore flag found. Skipping initial backup."
+        perform_initial_backup=false
+    else
+        echo "[Backup Manager] No restore flag found. Performing initial backup."
+    fi
+    # Clean up flag file now that we've checked it
+    rm -f "$restored_flag_path"
+
+    # Perform initial backup if needed
+    if [ "$perform_initial_backup" = true ]; then
+        perform_backup_once "$CONFIG_FILE_PATH" "$DB_FILE_PATH" "$EXECUTABLE_PATH" "$CLOUDREVE_DIR" "$BACKUP_PREFIX"
+        if [ $? -eq 0 ]; then
+            echo "[Backup Manager] Initial backup completed."
+        else
+            echo "[Backup Manager] WARNING: Initial backup failed."
+            # Decide if we should proceed anyway or exit? For now, proceed.
+        fi
+    fi
+
+    # Start the periodic backup loop
+    echo "[Backup Manager] Starting periodic backup loop..."
     while true; do
-        # Wait for the defined interval
-        local sync_interval=${SYNC_INTERVAL:-3600} # Default to 1 hour
-        echo "Periodic Sync: Next check in ${sync_interval} seconds..."
-        sleep $sync_interval
+        local sync_interval=${SYNC_INTERVAL:-3600} # Default to 1 hour (3600 seconds)
+        echo "[Backup Manager] Periodic Sync: Next cycle in ${sync_interval} seconds..."
+        sleep "$sync_interval"
 
-        # Perform the backup
-        echo "Periodic Sync: Starting backup cycle at $(date)"
+        echo "[Backup Manager] Periodic Sync: Starting cycle at $(date)"
         perform_backup_once "$CONFIG_FILE_PATH" "$DB_FILE_PATH" "$EXECUTABLE_PATH" "$CLOUDREVE_DIR" "$BACKUP_PREFIX"
-        # We don't necessarily need to exit the loop if one backup fails
+        # Log completion, ignore errors for the loop to continue
+        echo "[Backup Manager] Periodic Sync: Cycle finished."
     done
 }
 
 
-# --- Main Execution Logic ---
+# --- Main Script Execution ---
+
+# Activate Python environment
+echo "Activating Python venv..."
+source /opt/venv/bin/activate
+
+# Define paths
+CLOUDREVE_DIR="/opt/cloudreve"
+BACKUP_PREFIX="cloudreve_backup"
+CONFIG_FILE_PATH="${CLOUDREVE_DIR}/config.ini"
+DB_FILE_PATH="${CLOUDREVE_DIR}/cloudreve.db"
+EXECUTABLE_PATH="${CLOUDREVE_DIR}/cloudreve"
+RESTORE_FLAG_FILE="/tmp/backup_restored.flag" # Define flag file path
+
+# Export CLOUDREVE_DIR for Python functions if needed
+export CLOUDREVE_DIR
 
-# 1. Attempt Initial Restore
+# 1. Attempt Initial Restore (sets flag file on success)
 echo "--- Step 1: Attempting Initial Restore ---"
-download_latest_backup
+download_latest_backup # This function now creates $RESTORE_FLAG_FILE on success
 restore_exit_code=$?
-restore_flag_file="/tmp/backup_restored.flag"
 
-# Check restore outcome
-backup_was_restored=false
 if [ $restore_exit_code -ne 0 ]; then
-    echo "CRITICAL: Backup restoration attempt failed with error (Exit code: $restore_exit_code). Exiting."
+    echo "CRITICAL: Backup restoration attempt failed (Exit code: $restore_exit_code). Exiting."
+    # Optional: Clean up flag file even on failure?
+    rm -f "$RESTORE_FLAG_FILE"
     exit 1
-elif [ -f "$restore_flag_file" ]; then
-    echo "Restore successful: Backup found and restored."
-    backup_was_restored=true
-else
-    echo "Restore skipped: No backup file found in the dataset."
-    backup_was_restored=false
-fi
-# Clean up flag file regardless
-rm -f "$restore_flag_file"
-
-
-# 2. Initial Cloudreve Run (If necessary)
-echo "--- Step 2: Checking for Initial Config ---"
-if [ ! -f "$CONFIG_FILE_PATH" ]; then
-    echo "Config file ($CONFIG_FILE_PATH) not found. Running Cloudreve once to generate initial config..."
-    /opt/cloudreve/cloudreve -c "$CONFIG_FILE_PATH"
-    if [ ! -f "$CONFIG_FILE_PATH" ]; then
-        echo "CRITICAL: Cloudreve failed to create initial config file. Exiting."
-        exit 1
-    else
-         echo "Initial config file created by first run. Check logs for credentials if needed."
-    fi
-fi
-
-# 3. Start Cloudreve Main Process (in background temporarily to allow checks)
-echo "--- Step 3: Starting Cloudreve Main Process (background initially) ---"
-/opt/cloudreve/cloudreve -c "$CONFIG_FILE_PATH" &
-cloudreve_pid=$!
-
-# 4. Wait for Cloudreve to be Ready
-echo "--- Step 4: Waiting for Cloudreve Service ---"
-wait_for_cloudreve # Use the function defined earlier
-
-# 5. Perform Initial Backup (If No Restore Occurred)
-echo "--- Step 5: Checking for Initial Backup ---"
-if [ "$backup_was_restored" = false ]; then
-    echo "No backup was restored, performing initial backup of current state..."
-    perform_backup_once "$CONFIG_FILE_PATH" "$DB_FILE_PATH" "$EXECUTABLE_PATH" "$CLOUDREVE_DIR" "$BACKUP_PREFIX"
-    if [ $? -ne 0 ]; then
-        echo "Warning: Initial backup failed."
-        # Decide whether to continue or exit if initial backup fails
-    else
-        echo "Initial backup completed successfully."
-    fi
+elif [ -f "$RESTORE_FLAG_FILE" ]; then
+     echo "--- Step 1 Result: Restore successful. ---"
 else
-    echo "Backup was restored, skipping initial backup."
+     echo "--- Step 1 Result: Restore skipped (no backup found). ---"
 fi
-
-# 6. Start Periodic Sync Loop in Background
-echo "--- Step 6: Starting Periodic Sync Loop ---"
-sync_data_loop &
-sync_loop_pid=$!
-
-# 7. Bring Cloudreve to Foreground / Wait for it
-# Since Cloudreve was started in the background, we now wait for it.
-# If Cloudreve exits, this script will also exit.
-echo "--- Step 7: Cloudreve is running. Monitoring PID: $cloudreve_pid ---"
-wait $cloudreve_pid
-exit_code=$?
-echo "Cloudreve process exited with code $exit_code."
-
-# Optional: attempt to clean up background sync loop if Cloudreve exits unexpectedly
-echo "Attempting to terminate background sync loop (PID: $sync_loop_pid)..."
-kill $sync_loop_pid 2>/dev/null
-wait $sync_loop_pid 2>/dev/null # Wait briefly for it to terminate
-
-exit $exit_code
+# Flag file will be checked and removed by the background manager
+
+# 2. Start Background Backup Manager
+# It will wait for Cloudreve, check the flag file, do initial backup if needed, then loop.
+echo "--- Step 2: Starting Background Backup Manager ---"
+manage_backups_background "$RESTORE_FLAG_FILE" & # Pass flag file path
+backup_manager_pid=$!
+
+# 3. Start Cloudreve Main Process using exec
+# This handles first run (init+exit) and normal runs.
+# It becomes the container's main process.
+echo "--- Step 3: Starting Cloudreve Application (using exec) ---"
+exec /opt/cloudreve/cloudreve -c "$CONFIG_FILE_PATH"
+
+# --- Code below only runs if exec fails ---
+exec_failed_code=$?
+echo "CRITICAL: Failed to execute Cloudreve (Exit code: $exec_failed_code). Terminating background jobs..."
+# Attempt to kill the background backup manager if exec failed
+kill $backup_manager_pid 2>/dev/null
+# Attempt to kill Aria2 if it was started by CMD? This is harder to manage reliably here.
+exit $exec_failed_code