Update sync_data.sh

sync_data.sh

@@ -1,356 +1,273 @@
 #!/bin/bash
 
-# --- 环境配置检查 ---
+# --- 配置检查 ---
+# 检查 WebDAV 环境变量是否设置
 if [[ -z "$WEBDAV_URL" ]] || [[ -z "$WEBDAV_USERNAME" ]] || [[ -z "$WEBDAV_PASSWORD" ]]; then
-    echo "错误：缺少 WEBDAV_URL、WEBDAV_USERNAME 或 WEBDAV_PASSWORD 环境变量。"
-    echo "WebDAV 备份与恢复功能将被禁用。"
-    WEBDAV_ENABLED=false
-else
-    WEBDAV_ENABLED=true
-    WEBDAV_BACKUP_PATH=${WEBDAV_BACKUP_PATH:-"files_backups"} # 默认备份子目录
-    FULL_WEBDAV_URL="${WEBDAV_URL%/}" # 确保基础 URL 末尾无斜杠
-
-    # --- 检查并创建 WebDAV 备份目录 (修复版 Python 代码) ---
-    echo "检查并创建 WebDAV 备份目录 (路径: $WEBDAV_BACKUP_PATH)..."
-    python3 -c "
-import os
-import sys
-from urllib.parse import urljoin
-from webdav3.client import Client
-from webdav3.exceptions import RemoteResourceNotFound, MethodNotSupported, NoConnection
-
-options = {
-    'webdav_hostname': '$WEBDAV_URL',
-    'webdav_login':    '$WEBDAV_USERNAME',
-    'webdav_password': '$WEBDAV_PASSWORD'
-}
-backup_base_path = '$WEBDAV_BACKUP_PATH' # WebDAV 上的相对路径
-
-try:
-    client = Client(options)
-    # 确保基础 URL 可连接 (可选，但有助于早期发现连接问题)
-    # client.verify = True # 如果需要验证 SSL 证书
-    # if not client.check(): # check() 可能也依赖特定方法，先注释掉
-    #    print(f'错误：无法连接到 WebDAV 服务器: $WEBDAV_URL')
-    #    sys.exit(1)
-
-    
-    # 如果所有层级都成功，构造最终的完整 URL 用于后续操作
-    # 使用 Python 的 urljoin 来确保路径拼接正确
-    final_full_url = urljoin('$WEBDAV_URL' + ('/' if not '$WEBDAV_URL'.endswith('/') else ''), backup_base_path + ('/' if backup_base_path else ''))
-    print(f'WebDAV 备份目录准备就绪: {final_full_url}')
-    # 将最终的 URL 输出，让 Shell 可以捕获 (如果需要)
-    # print(f'FULL_WEBDAV_BACKUP_URL={final_full_url}') # 暂时不需要外部捕获
-
-except NoConnection as nc_e:
-    print(f'错误：初始化 WebDAV 连接失败: {nc_e}')
-    sys.exit(1)
-except Exception as e:
-    print(f'错误：处理 WebDAV 目录时发生严重错误: {e}')
-    sys.exit(1) # 初始化或目录处理阶段的严重错误直接退出
+    echo "错误：缺少必要的 WebDAV 环境变量 (WEBDAV_URL, WEBDAV_USERNAME, WEBDAV_PASSWORD)。"
+    echo "备份功能将不可用。"
+    # 根据你的需求，如果缺少环境变量就完全退出，或者只跳过备份相关功能
+    # 这里选择退出，因为脚本的主要目的是备份
+    exit 1
+fi
 
-"
-    # 检查 Python 脚本的退出码
-    if [ $? -ne 0 ]; then
-        echo "错误：初始化 WebDAV 备份目录失败。请检查日志。WebDAV 功能将禁用。"
-        WEBDAV_ENABLED=false
-    else
-        # 如果 Python 成功，设置完整的备份 URL (在 Python 内部拼接更安全，但这里简化处理)
-        if [ -n "$WEBDAV_BACKUP_PATH" ]; then
-             FULL_WEBDAV_URL=$(python3 -c "from urllib.parse import urljoin; print(urljoin('$FULL_WEBDAV_URL/', '$WEBDAV_BACKUP_PATH/'))")
-        fi
-         echo "WebDAV 备份将存储在: $FULL_WEBDAV_URL"
+# --- 路径和常量定义 ---
+# 定义要备份的本地目录 (修改点 1：明确指定路径)
+LOCAL_DATA_DIR="/home/user/data"
+# 定义备份文件名前缀 (修改点 2：更改前缀)
+BACKUP_PREFIX="data_backup_"
+# 定义 WebDAV 上的可选子目录路径
+WEBDAV_BACKUP_PATH=${WEBDAV_BACKUP_PATH:-""} # 默认为空，即 WebDAV 根目录
+# 构造完整的 WebDAV URL
+FULL_WEBDAV_URL="${WEBDAV_URL}"
+if [ -n "$WEBDAV_BACKUP_PATH" ]; then
+    # 确保 URL 拼接时斜杠正确
+    if [[ "${WEBDAV_URL}" != */ ]]; then
+        WEBDAV_URL="${WEBDAV_URL}/"
     fi
+    if [[ "${WEBDAV_BACKUP_PATH}" == /* ]]; then
+        WEBDAV_BACKUP_PATH="${WEBDAV_BACKUP_PATH:1}"
+    fi
+    FULL_WEBDAV_URL="${WEBDAV_URL}${WEBDAV_BACKUP_PATH}"
 fi
+# 定义 Python 虚拟环境路径 (如果需要，请修改)
+VENV_PATH="$HOME/venv/bin/activate"
+# 定义同步间隔（秒），默认为 600 秒 (10 分钟)
+SYNC_INTERVAL=${SYNC_INTERVAL:-600}
+# 定义保留的备份数量
+KEEP_BACKUPS=5
 
-# --- 下载最新备份并恢复 `./data` 文件夹 ---
-restore_backup() {
-    if [ "$WEBDAV_ENABLED" = false ]; then
-        echo "WebDAV 未配置或初始化失败，跳过恢复。"
-        return
-    fi
+# --- 虚拟环境激活 ---
+# 检查并激活 Python 虚拟环境 (如果 Python 脚本需要)
+if [ -f "$VENV_PATH" ]; then
+    echo "激活 Python 虚拟环境: $VENV_PATH"
+    source "$VENV_PATH"
+else
+    echo "警告：未找到 Python 虚拟环境 $VENV_PATH。如果 Python 脚本需要特定库，可能会失败。"
+fi
 
-    echo "开始从 WebDAV 下载最新 `/home/user/data` 备份..."
-    # 这部分 Python 代码用于下载、解压，暂时保持不变，因为错误不在于此
+# --- 函数定义 ---
+
+# 函数：从 WebDAV 恢复最新备份
+restore_backup() {
+    echo "开始从 WebDAV 下载最新备份..."
     python3 -c "
-# ... (你原来那一大坨用于下载和解压的 Python 代码放在这里，从 import sys 开始) ...
-# 确保 logging 和 sys 被正确导入和使用
 import sys
 import os
 import tarfile
 import requests
-from webdav3.client import Client
 import shutil
-import logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+from webdav3.client import Client
+
 options = {
-    'webdav_hostname': '$WEBDAV_URL', # 基础 URL
+    'webdav_hostname': '$FULL_WEBDAV_URL',
     'webdav_login': '$WEBDAV_USERNAME',
     'webdav_password': '$WEBDAV_PASSWORD'
 }
-backup_dir_path = '$WEBDAV_BACKUP_PATH' # WebDAV 上的备份子目录
-target_restore_dir = '/home/user' # 恢复的目标父目录
-local_target_name = 'data' # 要恢复的文件夹名称
+local_data_dir = '$LOCAL_DATA_DIR' # 使用变量
+backup_prefix = '$BACKUP_PREFIX' # 使用变量
+
 try:
     client = Client(options)
-    logging.info(f'正在列出 WebDAV 目录: {backup_dir_path}')
-    files_in_backup_dir = client.list(backup_dir_path)
-    backups = [f for f in files_in_backup_dir if f.endswith('.tar.gz') and os.path.basename(f).startswith('files_backup_')]
-    
+    # 过滤文件，使用正确的前缀 (修改点 2)
+    backups = [f for f in client.list() if f.endswith('.tar.gz') and f.startswith(backup_prefix)]
+
     if not backups:
-        logging.warning('在 WebDAV 上没有找到任何有效的 `/home/user/data` 备份文件。')
-        sys.exit(0) 
-    backups.sort(key=lambda x: os.path.basename(x), reverse=True)
-    latest_backup_rel_path = backups[0] 
-    latest_backup_filename = os.path.basename(latest_backup_rel_path)
-    # 使用正确的 FULL_WEBDAV_URL (已包含备份子路径)
-    latest_backup_full_url = '${FULL_WEBDAV_URL%/}/' + latest_backup_filename 
-    logging.info(f'找到最新备份文件：{latest_backup_filename} (路径: {latest_backup_rel_path})')
-    local_tmp_backup_path = f'/tmp/{latest_backup_filename}'
-    logging.info(f'开始下载备份文件从: {latest_backup_full_url}')
-    with requests.get(latest_backup_full_url, auth=('$WEBDAV_USERNAME', '$WEBDAV_PASSWORD'), stream=True) as r:
-        r.raise_for_status() 
-        with open(local_tmp_backup_path, 'wb') as f:
+        print(f'在 {options['webdav_hostname']} 没有找到前缀为 {backup_prefix} 的备份文件。')
+        # 如果没有备份，确保目标目录存在但为空可能是期望行为，或者直接退出
+        os.makedirs(local_data_dir, exist_ok=True)
+        print(f'确保目录 {local_data_dir} 存在。')
+        sys.exit(0) # 正常退出，因为没有备份可恢复
+
+    latest_backup = sorted(backups)[-1]
+    print(f'找到最新备份文件：{latest_backup}')
+    remote_file_url = f'{options['webdav_hostname']}/{latest_backup}' # 假设 URL 构造正确
+    local_temp_file = f'/tmp/{latest_backup}'
+
+    print(f'正在从 {remote_file_url} 下载...')
+    with requests.get(remote_file_url, auth=(options['webdav_login'], options['webdav_password']), stream=True) as r:
+        r.raise_for_status() # 检查 HTTP 错误
+        with open(local_temp_file, 'wb') as f:
             for chunk in r.iter_content(chunk_size=8192):
                 f.write(chunk)
-        logging.info(f'成功下载备份文件到: {local_tmp_backup_path}')
-    temp_extract_dir = '/tmp/restore_files_temp'
-    if os.path.exists(temp_extract_dir):
-        shutil.rmtree(temp_extract_dir) 
-    os.makedirs(temp_extract_dir, exist_ok=True)
-    logging.info(f'开始解压备份文件到: {temp_extract_dir}')
-    try:
-        with tarfile.open(local_tmp_backup_path, 'r:gz') as tar:
-            def is_within_directory(directory, target):
-                abs_directory = os.path.abspath(directory)
-                abs_target = os.path.abspath(target)
-                prefix = os.path.commonprefix([abs_directory, abs_target])
-                return prefix == abs_directory
-            
-            import io # 需要导入 io
-            def safe_extract(tar, path=".", members=None, *, numeric_owner=False):
-                for member in tar.getmembers():
-                    member_path = os.path.join(path, member.name)
-                    if not is_within_directory(path, member_path):
-                        raise Exception("Attempted Path Traversal in Tar File")
-                tar.extractall(path, members, numeric_owner=numeric_owner) 
-            
-            safe_extract(tar, path=temp_extract_dir) # 使用安全解压
-        logging.info(f'成功解压备份文件。')
-    except Exception as e:
-        logging.error(f'解压备份文件失败: {e}')
-        sys.exit(1)
-    extracted_files_path = os.path.join(temp_extract_dir, local_target_name)
-    local_target_path = os.path.join(target_restore_dir, local_target_name)
-    if os.path.isdir(extracted_files_path):
-        logging.info(f'在备份中找到 \'{local_target_name}\' 目录。准备恢复...')
-        if os.path.exists(local_target_path):
-            logging.warning(f'本地已存在 \'{local_target_path}\' 目录，将删除并替换为备份内容。')
-            try:
-                # 对于目录，优先使用 shutil.rmtree
-                if os.path.isdir(local_target_path):
-                     shutil.rmtree(local_target_path)
-                # 如果是文件或链接，用 os.remove 或 os.unlink
-                elif os.path.exists(local_target_path):
-                     os.remove(local_target_path)
-                logging.info(f'成功删除旧的 \'{local_target_path}\'。')
-            except Exception as e:
-                logging.error(f'删除旧的 \'{local_target_path}\' 失败: {e}')
-                sys.exit(1)
-        
-        try:
-            shutil.move(extracted_files_path, local_target_path)
-            logging.info(f'成功将备份恢复到 \'{local_target_path}\'。')
-        except Exception as e:
-            logging.error(f'移动解压后的 \'{local_target_name}\' 目录到 \'{local_target_path}\' 失败: {e}')
-            sys.exit(1)
+        print(f'成功下载备份文件到 {local_temp_file}')
+
+    if os.path.exists(local_temp_file):
+        print(f'准备恢复到目录: {local_data_dir}')
+        # 如果目录已存在，先清空它 (或者删除重建，取决于需求)
+        if os.path.exists(local_data_dir):
+            print(f'目录 {local_data_dir} 已存在，正在清空...')
+            # shutil.rmtree(local_data_dir) # 删除整个目录树
+            # 或者清空目录内容
+            for item in os.listdir(local_data_dir):
+                item_path = os.path.join(local_data_dir, item)
+                if os.path.isfile(item_path) or os.path.islink(item_path):
+                    os.unlink(item_path)
+                elif os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+        else:
+             os.makedirs(local_data_dir, exist_ok=True)
+
+        print(f'正在解压 {local_temp_file} 到 {local_data_dir}...')
+        # 解压备份文件 (修改点 1: 确保解压到正确的目录)
+        with tarfile.open(local_temp_file, 'r:gz') as tar:
+            tar.extractall(path=local_data_dir)
+        print(f'成功从 {latest_backup} 恢复备份到 {local_data_dir}')
+        os.remove(local_temp_file) # 清理临时文件
     else:
-        logging.warning(f'解压后的备份文件中未找到 \'{local_target_name}\' 目录。无法执行恢复。')
-    logging.info('开始清理临时文件...')
-    try:
-        os.remove(local_tmp_backup_path)
-        logging.info(f'已删除临时备份文件: {local_tmp_backup_path}')
-    except OSError as e:
-        logging.warning(f'删除临时备份文件 {local_tmp_backup_path} 时出错: {e}')
-    
-    try:
-        shutil.rmtree(temp_extract_dir)
-        logging.info(f'已删除临时解压目录: {temp_extract_dir}')
-    except OSError as e:
-        logging.warning(f'删除临时解压目录 {temp_extract_dir} 时出错: {e}')
-except Exception as e:
-    logging.error(f'恢复过程中发生意外错误: {e}')
-    sys.exit(1) # 恢复过程中的 Python 错误应该让脚本失败
+        print(f'错误：下载的备份文件 {local_temp_file} 未找到。')
 
+except requests.exceptions.RequestException as e:
+    print(f'下载备份时发生网络错误: {e}')
+    sys.exit(1)
+except Exception as e:
+    print(f'恢复备份时发生错误: {e}')
+    sys.exit(1)
 "
     # 检查 Python 脚本的退出码
-    python_exit_code=$?
+    if [ $? -ne 0 ]; then
+        echo "恢复备份过程中发生错误，脚本终止。"
+        exit 1
+    fi
+}
 
-    if [ $python_exit_code -eq 0 ]; then
-        echo "恢复过程 Python 部分成功执行。"
+# 函数：同步数据到 WebDAV
+sync_data() {
+    while true; do
+        echo "-----------------------------------------------------"
+        echo "开始同步过程于: $(date)"
+
+        # 检查本地数据目录是否存在
+        if [ ! -d "$LOCAL_DATA_DIR" ]; then
+            echo "警告：本地数据目录 $LOCAL_DATA_DIR 不存在。跳过此次备份。"
+            sleep $SYNC_INTERVAL
+            continue # 继续下一次循环
+        fi
         
-        # --- 新增权限设置 ---
-        if [ -d "/home/user/data" ]; then
-            echo "尝试为恢复后的 /home/user/data 目录设置权限 (u=rwX,g=rX,o=rX)..."
-            chmod -R u=rwX,g=rX,o=rX /home/user/data 
-            if [ $? -eq 0 ]; then
-                echo "成功设置 /home/user/data 目录权限。"
-            else
-                echo "警告：设置 /home/user/data 目录权限失败！"
-            fi
-        else
-             echo "未找到恢复后的 /home/user/data 目录或恢复未执行，跳过权限设置。"
+        # 检查本地数据目录是否为空
+        if [ -z "$(ls -A $LOCAL_DATA_DIR)" ]; then
+           echo "信息：本地数据目录 $LOCAL_DATA_DIR 为空。跳过此次备份。"
+           sleep $SYNC_INTERVAL
+           continue # 继续下一次循环
         fi
-        # --- 权限设置结束 ---
 
-        echo "恢复过程完成。"
-    else
-        echo "错误：恢复备份过程中发生错误，请检查 Python 日志。"
-        # 恢复失败通常是比较严重的问题，可以选择退出
-        # exit 1 
-    fi
-}
+        timestamp=$(date +%Y%m%d_%H%M%S)
+        # 使用新的前缀生成备份文件名 (修改点 2)
+        backup_file="${BACKUP_PREFIX}${timestamp}.tar.gz"
+        local_temp_backup_path="/tmp/${backup_file}"
+        remote_backup_path="${FULL_WEBDAV_URL}/${backup_file}" # 确保 URL 没有双斜杠
 
-# --- 首次启动时尝试恢复最新备份 ---
-echo "[Entrypoint] 首次启动，尝试从 WebDAV 恢复最新 `./data` 备份..."
-# 只有 WebDAV 启用且目录检查成功后才执行恢复
-if [ "$WEBDAV_ENABLED" = true ]; then
-    restore_backup
-else
-    echo "[Entrypoint] WebDAV 未启用或初始化失败，跳过首次恢复。"
-    # 如果没有恢复，检查本地是否存在 ./data，如果不存在可能需要创建空目录？
-    if [ ! -d "/home/user/data" ]; then
-       echo "[Entrypoint] 本地 /home/user/data 目录不存在，创建一个空的..."
-       mkdir /home/user/data
-       chmod u=rwX,g=rX,o=rX /home/user/data # 设置基本权限
-    fi
-fi
+        echo "正在压缩目录: $LOCAL_DATA_DIR 到 $local_temp_backup_path"
+        # 使用 tar 压缩指定目录的内容 (修改点 1: 使用正确的源目录)
+        # -C "$LOCAL_DATA_DIR" 表示先切换到该目录，然后压缩 '.' (当前目录的所有内容)
+        # --warning=no-file-changed 忽略文件在压缩过程中改变的警告
+        tar --warning=no-file-changed -czf "$local_temp_backup_path" -C "$LOCAL_DATA_DIR" .
 
+        if [ $? -ne 0 ]; then
+            echo "错误：压缩目录 $LOCAL_DATA_DIR 失败。"
+            rm -f "$local_temp_backup_path" # 清理可能存在的坏文件
+            sleep $SYNC_INTERVAL
+            continue # 继续下一次循环
+        fi
+        
+        # 检查压缩文件大小
+        if [ ! -s "$local_temp_backup_path" ]; then
+            echo "错误：压缩后的文件 $local_temp_backup_path 大小为 0 或不存在。跳过上传。"
+            rm -f "$local_temp_backup_path"
+            sleep $SYNC_INTERVAL
+            continue
+        fi
 
-# --- 定时同步函数 (备份 `/home/user/data` 文件夹) ---
-sync_data() {
-    if [ "$WEBDAV_ENABLED" = false ]; then
-        echo "[Sync] WebDAV 未配置或初始化失败，跳过后台同步任务。"
-        return
-    fi
 
-    while true; do
-        # 获取同步间隔，默认 10 分钟 (600 秒)
-        SYNC_INTERVAL=${SYNC_INTERVAL:-600}
-        echo "[Sync] 下一次 `/home/user/data` 备份将在 ${SYNC_INTERVAL} 秒后进行..."
-        sleep $SYNC_INTERVAL
+        echo "正在上传备份文件: $local_temp_backup_path 到 $remote_backup_path"
+        # 使用 curl 上传文件到 WebDAV
+        curl --fail -u "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" -T "$local_temp_backup_path" "$remote_backup_path"
 
-        echo "[Sync][$(date)] 开始执行 `/home/user/data` 备份和同步..."
+        if [ $? -eq 0 ]; then
+            echo "成功上传 ${backup_file} 到 WebDAV"
 
-        # 检查 `/home/user/data` 目录是否存在
-        if [ -d "/home/user/data" ]; then
-            timestamp=$(date +%Y%m%d_%H%M%S)
-            backup_file="files_backup_${timestamp}.tar.gz"
-            local_tmp_backup_path="/tmp/${backup_file}"
+            # 上传成功后，清理本地临时文件
+            echo "清理本地临时文件: $local_temp_backup_path"
+            rm -f "$local_temp_backup_path"
 
-            echo "[Sync] 找到 `/home/user/data` 目录，开始创建备份文件: ${backup_file}"
-            # 打包 /home/user/data 目录
-            tar -czf "${local_tmp_backup_path}" /home/user/data
-            if [ $? -ne 0 ]; then
-                echo "[Sync] 错误：创建 tar 备份文件 ${backup_file} 失败！跳过此次同步。"
-                rm -f "${local_tmp_backup_path}" # 清理可能产生的坏文件
-                continue 
-            fi
-            echo "[Sync] 成功创建本地备份文件: ${local_tmp_backup_path}"
-
-            # 上传新备份到WebDAV (使用正确的完整 URL)
-            webdav_upload_url="${FULL_WEBDAV_URL%/}/${backup_file}" 
-            echo "[Sync] 开始上传 ${backup_file} 到 ${webdav_upload_url}"
-            curl --fail --silent --show-error -u "$WEBDAV_USERNAME:$WEBDAV_PASSWORD" -T "${local_tmp_backup_path}" "${webdav_upload_url}"
-            curl_exit_code=$? # 保存 curl 退出码
-
-            if [ $curl_exit_code -eq 0 ]; then
-                echo "[Sync] 成功将 ${backup_file} 上传至 WebDAV"
-                rm -f "${local_tmp_backup_path}"
-                echo "[Sync] 已清理本地临时备份文件: ${local_tmp_backup_path}"
-
-                # 清理 WebDAV 上的旧备份文件（保留最新的5个）
-                echo "[Sync] 开始清理 WebDAV 上的旧备份..."
-                python3 -c "
-# ... (清理旧备份的 Python 代码基本不变���确认变量名正确) ...
+            # 清理 WebDAV 上的旧备份文件
+            echo "开始清理 WebDAV 上的旧备份..."
+            python3 -c "
 import sys
-import os
 from webdav3.client import Client
-import logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
 options = {
-    'webdav_hostname': '$WEBDAV_URL', # 基础 URL
+    'webdav_hostname': '$FULL_WEBDAV_URL',
     'webdav_login': '$WEBDAV_USERNAME',
     'webdav_password': '$WEBDAV_PASSWORD'
 }
-backup_dir_path = '$WEBDAV_BACKUP_PATH' # WebDAV 上的备份子目录
-keep_latest = 5 # 保留最新的备份数量
+backup_prefix = '$BACKUP_PREFIX' # 使用变量
+keep_backups = $KEEP_BACKUPS # 使用变量
+
 try:
     client = Client(options)
-    logging.info(f'正在列出 WebDAV 目录: {backup_dir_path} 以进行清理')
-    # 使用 remote_path 参数指定要列出的目录
-    files_in_backup_dir_info = client.list(remote_path=backup_dir_path, get_info=True) 
-    # 过滤出咱们的备份文件，现在 list 返回的是字典列表，需要取 'path' 或 'name'
-    # 取 'path' 通常是相对于 hostname 的完整路径
-    backups = [f['path'] for f in files_in_backup_dir_info if f['path'].endswith('.tar.gz') and os.path.basename(f['path']).startswith('files_backup_')]
-    
-    # 按文件名（包含时间戳）排序，旧的在前
-    backups.sort(key=lambda x: os.path.basename(x))
-    
-    if len(backups) > keep_latest:
-        to_delete_count = len(backups) - keep_latest
-        logging.info(f'找到 {len(backups)} 个备份，超过限制 {keep_latest} 个，将删除最旧的 {to_delete_count} 个。')
-        for backup_to_delete_rel_path in backups[:to_delete_count]:
+    # 过滤文件，使用正确的前缀 (修改点 2)
+    backups = [f for f in client.list() if f.endswith('.tar.gz') and f.startswith(backup_prefix)]
+    backups.sort() # 按名称排序（时间戳）
+
+    if len(backups) > keep_backups:
+        to_delete_count = len(backups) - keep_backups
+        print(f'找到 {len(backups)} 个备份，超过了保留数量 {keep_backups}，将删除最早的 {to_delete_count} 个。')
+        for file_to_delete in backups[:to_delete_count]:
             try:
-                # clean 需要的是相对路径
-                client.clean(backup_to_delete_rel_path) 
-                logging.info(f'成功删除旧备份: {backup_to_delete_rel_path}')
-            except Exception as e:
-                logging.error(f'删除旧备份 {backup_to_delete_rel_path} 失败: {e}')
+                # 确保路径正确，对于根目录下的文件，不需要加斜杠
+                delete_path = file_to_delete
+                print(f'正在删除旧备份: {delete_path}')
+                client.clean(delete_path) # clean 方法通常用于删除文件或目录
+                print(f'成功删除 {delete_path}')
+            except Exception as delete_err:
+                print(f'删除文件 {delete_path} 时出错: {delete_err}')
     else:
-        logging.info(f'找到 {len(backups)} 个备份，未超过限制 {keep_latest} 个，无需清理。')
+        print(f'找到 {len(backups)} 个备份，未达到保留上限 {keep_backups}，无需清理。')
+
 except Exception as e:
-    logging.error(f'清理旧备份时发生错误: {e}')
+    print(f'清理旧备份时发生错误: {e}')
 "
-                if [ $? -ne 0 ]; then
-                    echo "[Sync] 清理 WebDAV 旧备份时发生错误，请检查日志。"
-                else
-                    echo "[Sync] WebDAV 旧备份清理完成。"
-                fi
-
-            else
-                echo "[Sync] 错误：上传 ${backup_file} 至 WebDAV 失败！(curl 退出码: ${curl_exit_code}) 请检查网络或 WebDAV 服务器状态。"
-                rm -f "${local_tmp_backup_path}"
-                echo "[Sync] 已清理上传失败的本地临时备份文件: ${local_tmp_backup_path}"
+            if [ $? -ne 0 ]; then
+                echo "警告：清理 WebDAV 旧备份时发生错误。"
             fi
+
         else
-            echo "[Sync] 目标目录 `/home/user/data` 不存在或不是一个目录，跳过此次备份。"
+            echo "错误：上传 ${backup_file} 到 WebDAV 失败。返回码: $?"
+            # 上传失败，也清理本地临时文件
+            echo "清理本地临时文件: $local_temp_backup_path"
+            rm -f "$local_temp_backup_path"
         fi
-        
-        echo "[Sync][$(date)] 同步进程结束。"
+
+        echo "下次同步将在 ${SYNC_INTERVAL} 秒后进行..."
+        sleep $SYNC_INTERVAL
     done
 }
 
-# --- 启动后台同步进程 ---
-# 只有在 WebDAV 启用且目录检查成功后才启动后台同步
-if [ "$WEBDAV_ENABLED" = true ]; then
-    echo "[Entrypoint] 启动后台 `/home/user/data` 备份同步进程 (sync_data.sh)..."
-    sync_data &
-else
-    echo "[Entrypoint] WebDAV 未启用或初始化失败，后台备份同步任务已禁用。"
-fi
+# --- 主逻辑 ---
+
+# 1. 首次启动时尝试恢复最新备份 (可选，根据你的需求决定是否需要)
+echo "检查并恢复最新备份（如果存在）..."
+restore_backup
 
-# --- 主逻辑完成，保持运行 (根据你的应用需求决定) ---
-echo "[Entrypoint] 脚本主要逻辑执行完毕。后台同步任务（如果启用）正在运行。"
-echo "[Entrypoint] 你可以在这里启动你的主应用程序，例如 'exec python main.py'"
-echo "[Entrypoint] 或者，如果此脚本是容器的唯一进程，使用 'wait' 或其他方法保持容器运行。"
+# 2. 等待一段时间后启动应用程序 (如果需要)
+# 如果你不需要这个脚本来启动其他应用，可以注释掉下面两行
+# echo "等待 30 秒后启动应用程序..."
+# sleep 30
+# echo "启动应用程序..."
+# ./app server & # 你的应用程序启动命令
 
-# 如果需要这个脚本保持前台运行（例如作为 Docker CMD/ENTRYPOINT 且没有其他前台进程）
-# 可以取消下面这行的注释，或者更好地让你的主应用跑在前台
-# wait $! # 等待最后一个后台进程 (sync_data) 结束，如果 sync_data 意外退出，容器也会退出
+# 3. 启动后台同步进程
+echo "启动后台数据同步进程..."
+sync_data &
 
-# 如果只是需要保持容器运行，而 sync_data 是无限循环的后台任务
-# 可以用 tail -f /dev/null 或 sleep infinity
-# tail -f /dev/null
-exec "$@" # 如果这个脚本是 entrypoint，允许执行 CMD 传入的命令
+# 让主脚本保持运行（如果需要，例如在 Docker 容器中）
+# 如果上面的 `./app server &` 是前台运行的，或者你用其他方式保持脚本运行，就不需要这个
+# 如果 `sync_data` 是唯一需要长时间运行的，它已经在后台了，主脚本可以退出
+# 但如果这是容器的主进程，你可能需要一个前台等待
+# 例如: wait $! # 等待最后一个后台进程 (sync_data)
+# 或者，如果启动了 app server: wait $(pgrep -f app server) # 等待 app server 进程
+# 或者简单地无限循环:
+# tail -f /dev/null # 保持脚本在前台运行
 
+echo "脚本初始化完成，同步进程已在后台运行。"
+# 根据你的运行环境决定脚本最后如何结束或保持运行