iamt 1.1.27__py3-none-any.whl

iamt/dcd/dcd.py

@@ -0,0 +1,337 @@
+"""DCD 模块 - Docker Compose 部署管理
+
+提供以下命令:
+- iamt dcd ls: 列出所有可用的 docker compose 模块
+- iamt dcd x: 交互式部署 docker compose 模块到远程服务器
+- iamt dcd file: 从配置文件执行部署任务
+"""
+
+from pathlib import Path
+from typing import TypedDict
+
+import questionary
+import yaml
+from prompt_toolkit import prompt
+from rich.console import Console
+from rich.table import Table
+
+from ..completers.customCompleter import CustomCompleter, CustomValidator
+from ..utils.config_saver import TaskCall, save_task_config, get_hostname_from_iamt_config
+
+
+# region 常量配置
+
+COMPOSES_DIR = Path(__file__).parent.parent / "composes"
+DCD_CONFIG_SUFFIX = ".dcd.yaml"
+
+# endregion
+
+
+# region 类型定义
+
+
+class ComposeModule(TypedDict):
+    """Docker Compose 模块信息"""
+    name: str             # 模块名称
+    category: str         # 所属分类
+    path: Path            # 模块路径
+
+
+class DCDConfig(TypedDict):
+    """DCD 配置文件结构"""
+    hostname: str
+    tasks: list[TaskCall]
+
+# endregion
+
+
+class DCD:
+    """Docker Compose 部署管理类"""
+
+    def __init__(self):
+        self._console = Console()
+
+    # region iamt dcd ls - 列出所有 compose 模块
+
+    def ls(self) -> None:
+        """列出所有可用的 docker compose 模块"""
+        modules = self._scan_compose_modules()
+        if not modules:
+            self._console.print("[yellow]未找到任何 docker compose 模块[/yellow]")
+            return
+
+        table = Table(title="Docker Compose 模块列表", show_lines=False)
+        table.add_column("分类", style="cyan")
+        table.add_column("模块名", style="green")
+        table.add_column("路径", style="dim")
+
+        for module in modules:
+            table.add_row(module["category"], module["name"], str(module["path"].relative_to(COMPOSES_DIR)))
+
+        self._console.print(table)
+        self._console.print(f"\n[dim]共 {len(modules)} 个模块[/dim]")
+
+    def _scan_compose_modules(self) -> list[ComposeModule]:
+        """扫描 composes 目录下所有包含 docker-compose.yml 的模块
+        
+        Returns:
+            包含所有找到的 compose 模块信息的列表
+        """
+        modules: list[ComposeModule] = []
+        if not COMPOSES_DIR.exists():
+            return modules
+
+        for category_dir in sorted(COMPOSES_DIR.iterdir()):
+            if not category_dir.is_dir() or category_dir.name.startswith("."):
+                continue
+
+            for module_dir in sorted(category_dir.iterdir()):
+                if not module_dir.is_dir():
+                    continue
+
+                compose_file = module_dir / "docker-compose.yml"
+                if compose_file.exists():
+                    modules.append({
+                        "name": module_dir.name,
+                        "category": category_dir.name,
+                        "path": module_dir,
+                    })
+
+        return modules
+
+    # endregion
+
+    # region iamt dcd x - 交互式部署
+
+    def x(self, force: bool = False, start: bool = False) -> None:
+        """交互式部署 docker compose 模块到远程服务器
+
+        Args:
+            force: 强制执行，若远程目录已存在且有 compose 项目运行，会先停止并删除
+            start: 部署完成后是否立即启动项目
+        """
+        from ..client_config.client_config import ClientConfig
+
+        # region 选择 compose 模块
+        modules = self._scan_compose_modules()
+        if not modules:
+            self._console.print("[red]未找到任何 docker compose 模块[/red]")
+            return
+
+        module_choices = {f"{m['category']}/{m['name']}": f"{m['category']}/{m['name']}" for m in modules}
+        completer = CustomCompleter(module_choices)
+        validator = CustomValidator(completer, "无效的模块，请从补全列表中选择。")
+
+        try:
+            selected = prompt(
+                "请选择要部署的 docker compose 模块: ",
+                completer=completer,
+                validator=validator,
+            )
+        except (KeyboardInterrupt, EOFError):
+            self._console.print("[yellow]已取消[/yellow]")
+            return
+
+        if not selected:
+            self._console.print("[yellow]已取消[/yellow]")
+            return
+
+        selected_module = modules[list(module_choices.keys()).index(selected)]
+        # endregion
+
+        # region 获取远程部署目录
+        default_remote_dir = f"/opt/docker/{selected_module['name']}"
+        remote_dir = questionary.text(
+            "请输入远程部署目录:",
+            default=default_remote_dir,
+        ).ask()
+
+        if remote_dir is None:
+            self._console.print("[yellow]已取消[/yellow]")
+            return
+        # endregion
+
+        # region 确认并执行部署
+        config = ClientConfig()
+        conn = config.connect()
+        if conn is None:
+            self._console.print("[red]无法连接到服务器[/red]")
+            return
+
+        host_info = f"{conn.user}@{conn.host}:{conn.port}"
+        mode_hints = []
+        if force:
+            mode_hints.append("强制模式")
+        if start:
+            mode_hints.append("部署后启动")
+        mode_hint = f" [{', '.join(mode_hints)}]" if mode_hints else ""
+        confirm = questionary.confirm(
+            f"确认部署 {selected} 到 {host_info}:{remote_dir}?{mode_hint}",
+            default=True,
+        ).ask()
+
+        if not confirm:
+            self._console.print("[yellow]已取消[/yellow]")
+            return
+        # endregion
+
+        # region 执行部署任务
+        from ..modules.dcdtask.dcdtask import compose_up, deploy_compose_module
+
+        # 记录执行的 task 调用
+        executed_tasks: list[TaskCall] = []
+
+        deploy_args = {
+            "local_path": str(selected_module["path"]),
+            "remote_dir": remote_dir,
+            "force": force,
+        }
+        success, msg = deploy_compose_module(conn, **deploy_args)
+        executed_tasks.append({"task": "dcdtask.deploy_compose_module", "args": deploy_args})
+
+        if not success:
+            self._console.print(f"[red]部署失败: {msg}[/red]")
+            return
+
+        if start:
+            up_args = {"remote_dir": remote_dir}
+            compose_up(conn, **up_args)
+            executed_tasks.append({"task": "dcdtask.compose_up", "args": up_args})
+        # endregion
+
+        # region 保存配置文件
+        save_config = questionary.confirm(
+            "是否保存部署配置到当前目录?",
+            default=True,
+        ).ask()
+
+        if save_config:
+            config_name = Path(remote_dir).name
+            save_task_config(
+                hostname=get_hostname_from_iamt_config(),
+                tasks=executed_tasks,
+                config_name=config_name,
+                suffix=DCD_CONFIG_SUFFIX,
+            )
+        # endregion
+
+    # endregion
+
+    # region iamt dcd file - 从配置文件部署
+
+    def file(self) -> None:
+        """从当前目录的配置文件执行部署任务
+        
+        扫描当前目录下的 .dcd.yaml 配置文件，读取其中的主机和任务信息，
+        连接到目标服务器并按顺序执行配置的部署任务。
+        """
+        from ..client_config.client_config import ClientConfig
+
+        # region 扫描配置文件
+        dcd_config_files = list(Path.cwd().glob(f"*{DCD_CONFIG_SUFFIX}"))
+        if not dcd_config_files:
+            self._console.print(f"[yellow]当前目录未找到 {DCD_CONFIG_SUFFIX} 配置文件[/yellow]")
+            return
+        # endregion
+
+        # region 选择配置文件
+        if len(dcd_config_files) == 1:
+            selected_file = dcd_config_files[0]
+        else:
+            file_choices = [f.name for f in dcd_config_files]
+            selected_name = questionary.select(
+                "请选择配置文件:",
+                choices=file_choices,
+            ).ask()
+
+            if selected_name is None:
+                self._console.print("[yellow]已取消[/yellow]")
+                return
+
+            selected_file = Path.cwd() / selected_name
+        # endregion
+
+        # region 读取配置
+        try:
+            config_data: DCDConfig = yaml.safe_load(selected_file.read_text(encoding="utf-8"))
+        except Exception as e:
+            self._console.print(f"[red]读取配置文件失败: {e}[/red]")
+            return
+
+        hostname = config_data.get("hostname", "")
+        tasks = config_data.get("tasks", [])
+
+        if not hostname:
+            self._console.print("[red]配置文件缺少 hostname[/red]")
+            return
+        if not tasks:
+            self._console.print("[red]配置文件缺少 tasks[/red]")
+            return
+        # endregion
+
+        # region 验证 hostname 并创建连接
+        client_config = ClientConfig()
+        if not client_config.config_file.exists():
+            self._console.print("[red]未找到 iamt.yaml 配置文件[/red]")
+            return
+
+        iamt_config = yaml.safe_load(client_config.config_file.read_text(encoding="utf-8"))
+        hosts = iamt_config.get("hosts", {})
+        if hostname not in hosts:
+            self._console.print(f"[red]iamt.yaml 中未找到主机: {hostname}[/red]")
+            return
+
+        conn = client_config.connect(hostname)
+        if conn is None:
+            self._console.print("[red]无法连接到服务器[/red]")
+            return
+        # endregion
+
+        # region 显示配置信息并确认
+        self._console.print(f"[cyan]配置文件: {selected_file.name}[/cyan]")
+        self._console.print(f"[cyan]目标主机: {hostname}[/cyan]")
+        self._console.print("[cyan]待执行任务:[/cyan]")
+        for t in tasks:
+            self._console.print(f"  - {t['task']}: {t['args']}")
+
+        confirm = questionary.confirm("确认执行部署?", default=True).ask()
+        if not confirm:
+            self._console.print("[yellow]已取消[/yellow]")
+            return
+        # endregion
+
+        # region 执行 tasks
+        from ..modules.dcdtask import dcdtask as dcdtask_module
+
+        for task_call in tasks:
+            task_name = task_call["task"]
+            task_args = task_call["args"].copy()
+
+            # 解析 task 名称 (格式: module.function)
+            parts = task_name.split(".")
+            if len(parts) != 2:
+                self._console.print(f"[red]无效的 task 名称: {task_name}[/red]")
+                continue
+
+            module_name, func_name = parts
+
+            # 获取 task 函数
+            try:
+                task_func = getattr(dcdtask_module, func_name, None)
+                if task_func is None:
+                    self._console.print(f"[red]未找到 task 函数: {task_name}[/red]")
+                    continue
+            except Exception as e:
+                self._console.print(f"[red]加载 task 失败: {task_name}, {e}[/red]")
+                continue
+
+            # 执行 task
+            self._console.print(f"[cyan]执行: {task_name}[/cyan]")
+            try:
+                task_func(conn, **task_args)
+            except Exception as e:
+                self._console.print(f"[red]执行失败: {e}[/red]")
+                return
+        # endregion
+
+    # endregion

iamt/decorators/singleton.py

@@ -0,0 +1,224 @@
+"""
+单例模式装饰器实现
+提供线程安全的单例模式装饰器，确保类只能创建一个实例。
+"""
+
+import threading
+from functools import wraps
+from typing import Dict, Type, Any, Optional
+
+
+class Singleton:
+    """
+    单例模式装饰器类
+    使用@Singleton装饰器方式实现单例模式，线程安全。
+    
+    Example:
+        @Singleton
+        class ConfigManager:
+            def __init__(self):
+                if hasattr(self, '_initialized'):
+                    return
+                self._initialized = True
+                self.config = {}
+                
+        # 使用
+        config1 = ConfigManager()
+        config2 = ConfigManager()
+        assert config1 is config2  # True
+    """
+    
+    def __init__(self, cls: Type):
+        """
+        初始化单例装饰器
+        Args:
+            cls: 要应用单例模式的类
+        """
+        self._cls = cls
+        self._instance: Optional[Any] = None
+        self._lock = threading.Lock()
+        
+        # 保持原类的属性
+        self.__name__ = cls.__name__
+        self.__doc__ = cls.__doc__
+        self.__module__ = cls.__module__
+        self.__qualname__ = cls.__qualname__
+    
+    def __call__(self, *args, **kwargs):
+        """
+        实现单例逻辑的调用方法
+        使用双重检查锁定确保线程安全
+        """
+        if self._instance is None:
+            with self._lock:
+                if self._instance is None:
+                    self._instance = self._cls(*args, **kwargs)
+        return self._instance
+    
+    def reset_instance(self):
+        """重置单例实例（主要用于测试）"""
+        with self._lock:
+            self._instance = None
+    
+    def get_instance_count(self):
+        """获取实例数量"""
+        return 1 if self._instance is not None else 0
+    
+    def get_original_class(self):
+        """获取原始类"""
+        return self._cls
+    
+    @property
+    def instance(self):
+        """获取当前实例（如果存在）"""
+        return self._instance
+
+# 一旦一个类被 Sginleton 装饰 这个类就会变成一个Singleton实例 
+# 被装饰类初始化的时候 其实会嗲用 Singleton的 call 方法 直接从Singleton实例当中返回 被装饰类的实例  
+
+
+
+
+
+class SingletonMeta(type):
+    """
+    线程安全的单例元类实现
+    
+    使用方式:
+        class MyClass(metaclass=SingletonMeta):
+            def __init__(self):
+                self.value = "singleton"
+    
+    特点:
+    - 线程安全的双重检查锁定
+    - 支持继承
+    - 支持多重继承
+    - 每个类维护独立的单例实例
+    
+    Example:
+        class DatabaseManager(metaclass=SingletonMeta):
+            def __init__(self):
+                self.connections = {}
+        
+        class CacheService(DatabaseManager):  # 继承也是单例
+            def __init__(self):
+                super().__init__()
+                self.cache = {}
+        
+        # 使用
+        db1 = DatabaseManager()
+        db2 = DatabaseManager()
+        assert db1 is db2  # True
+        
+        cache1 = CacheService()
+        cache2 = CacheService()
+        assert cache1 is cache2  # True
+        assert cache1 is not db1  # True (不同类有不同实例)
+    """
+    _instances: Dict[Type, Any] = {}
+    _lock: threading.Lock = threading.Lock()
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            with cls._lock:
+                # 双重检查锁定模式
+                if cls not in cls._instances:
+                    instance = super().__call__(*args, **kwargs)
+                    cls._instances[cls] = instance
+        return cls._instances[cls]
+    
+    @classmethod
+    def reset_all_instances(mcs):
+        """重置所有单例实例（主要用于测试）"""
+        with mcs._lock:
+            mcs._instances.clear()
+    
+    @classmethod
+    def get_instance_info(mcs):
+        """获取所有单例实例信息"""
+        return {cls.__name__: id(instance) for cls, instance in mcs._instances.items()}
+
+
+def singleton(cls: Type) -> Type:
+    """
+    单例模式装饰器
+    使用装饰器方式实现单例模式，线程安全。
+    Args:
+        cls: 要应用单例模式的类
+    Returns:
+        应用了单例模式的类
+    """
+    instances: Dict[Type, Any] = {}
+    lock = threading.Lock()
+    
+    @wraps(cls)
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            with lock:
+                if cls not in instances:
+                    instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+    
+    return get_instance
+
+
+def thread_safe_singleton(cls: Type) -> Type:
+    """
+    线程安全的单例装饰器（增强版）
+    提供更强的线程安全保证和实例管理功能。
+    
+    Args:
+        cls: 要应用单例模式的类
+        
+    Returns:
+        应用了单例模式的类
+    """
+    instances: Dict[Type, Any] = {}
+    locks: Dict[Type, threading.Lock] = {}
+    main_lock = threading.Lock()
+    
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            # 为每个类创建独立的锁
+            if cls not in locks:
+                with main_lock:
+                    if cls not in locks:
+                        locks[cls] = threading.Lock()
+            
+            with locks[cls]:
+                if cls not in instances:
+                    instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+    
+    # 保持原类的属性
+    get_instance.__name__ = cls.__name__
+    get_instance.__doc__ = cls.__doc__
+    get_instance.__module__ = cls.__module__
+    get_instance.__qualname__ = cls.__qualname__
+    
+    # 添加实用方法
+    def reset_instance():
+        """重置单例实例（主要用于测试）"""
+        if cls in instances:
+            with locks.get(cls, threading.Lock()):
+                if cls in instances:
+                    del instances[cls]
+    
+    def get_instance_count():
+        """获取实例数量"""
+        return 1 if cls in instances else 0
+    
+    get_instance.reset_instance = reset_instance
+    get_instance.get_instance_count = get_instance_count
+    get_instance._original_class = cls
+    
+    return get_instance
+
+
+# 导出的公共接口
+__all__ = [
+    'singleton',
+    'Singleton', 
+    'SingletonMeta',
+    'thread_safe_singleton'
+]

iamt/modules/_utils/_utils.py

@@ -0,0 +1 @@
+# 此文件内容已移动到 setup_apt_sources.py

iamt/modules/_utils/arch.py

@@ -0,0 +1,22 @@
+"""架构转换工具模块"""
+
+# 架构映射表 (uname -m -> dpkg architecture)
+ARCH_MAP = {
+    "x86_64": "amd64",
+    "aarch64": "arm64",
+    "armv7l": "armhf",
+    "i686": "i386",
+    "i386": "i386",
+}
+
+
+def normalize_arch(uname_arch: str) -> str:
+    """将 uname -m 输出转换为 dpkg 架构格式
+
+    Args:
+        uname_arch: uname -m 的输出 (如 x86_64, aarch64)
+
+    Returns:
+        dpkg 架构名称 (如 amd64, arm64)
+    """
+    return ARCH_MAP.get(uname_arch, uname_arch)

iamt/modules/_utils/cleanup_network_config.py

@@ -0,0 +1,68 @@
+from fabric import Connection, task
+
+
+@task
+def cleanup_network_config(conn: Connection) -> None:
+    """根据系统类型清理静态 IP 配置"""
+    distro_id = conn.hostvars.get("distribution", {}).get("id", "").lower()
+    
+    if distro_id == "ubuntu":
+        _cleanup_ubuntu_netplan(conn)
+    else:
+        _cleanup_debian_interfaces(conn)
+
+
+# region Ubuntu (netplan)
+def _cleanup_ubuntu_netplan(conn: Connection) -> None:
+    """清理 Ubuntu netplan 配置，恢复 DHCP"""
+    print("  检测到 Ubuntu，清理 netplan 配置...")
+    
+    # 查找非默认的 netplan 配置文件
+    result = conn.sudo("find /etc/netplan/ -name '*.yaml' -type f 2>/dev/null || true")
+    files = [f.strip() for f in result.stdout.strip().split("\n") if f.strip()]
+    
+    # 删除自定义配置文件（保留系统默认的 00-installer-config.yaml 或 01-netcfg.yaml）
+    default_files = {"01-network-manager-all.yaml","00-installer-config.yaml", "01-netcfg.yaml", "50-cloud-init.yaml"}
+    for f in files:
+        filename = f.split("/")[-1]
+        if filename not in default_files:
+            conn.sudo(f"rm -f {f}")
+            print(f"  已删除: {f}")
+    
+#     # 生成默认 DHCP 配置
+#     dhcp_config = """
+# network:
+#   version: 2
+#   ethernets:
+#     enp0s8:
+#       dhcp4: true
+# """
+#     conn.sudo(f"bash -c \"echo '{dhcp_config}' > /etc/netplan/50-dhcp.yaml\"")
+#     conn.sudo("chmod 600 /etc/netplan/50-dhcp.yaml")
+#     print("  已创建 DHCP 配置: /etc/netplan/50-dhcp.yaml")
+    
+    # 应用 netplan 配置（执行后网络会变更，连接将断开）
+    conn.sudo("netplan apply", warn=True)
+    print("  已应用 netplan 配置，正在断开连接...")
+    conn.close()
+# endregion
+
+
+# region Debian (interfaces)
+def _cleanup_debian_interfaces(conn: Connection) -> None:
+    """清理 Debian 传统 interfaces 配置"""
+    print("  检测到 Debian，清理 interfaces 配置...")
+    
+    # 查找并删除 interfaces.d 下的配置文件
+    result = conn.sudo("find /etc/network/interfaces.d/ -type f 2>/dev/null || true")
+    files = [f.strip() for f in result.stdout.strip().split("\n") if f.strip()]
+    
+    for f in files:
+        conn.sudo(f"rm -f {f}")
+        print(f"  已删除: {f}")
+    
+    # 重启网络服务
+    if files:
+        conn.sudo("systemctl restart networking", warn=True)
+        print("  已重启网络服务")
+# endregion