732 lines
30 KiB
Python
732 lines
30 KiB
Python
"""
|
||
tools/ssh_docker.py
|
||
SSH 远程 Docker 部署工具 —— 所有配置通过 settings.tools['ssh_docker'][key] 获取
|
||
依赖: pip install paramiko>=3.0.0
|
||
"""
|
||
|
||
import json
|
||
import re
|
||
import time
|
||
from dataclasses import dataclass, field
|
||
|
||
from config.settings import settings
|
||
from utils.logger import get_logger
|
||
|
||
logger = get_logger("TOOL.SSHDocker")
|
||
|
||
try:
|
||
import paramiko
|
||
_PARAMIKO_AVAILABLE = True
|
||
except ImportError:
|
||
_PARAMIKO_AVAILABLE = False
|
||
logger.warning("⚠️ paramiko 未安装，请执行: pip install paramiko>=3.0.0")
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 配置访问快捷函数
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
def _cfg(key: str, fallback=None):
|
||
"""读取 ssh_docker 工具配置，不存在时返回 fallback"""
|
||
return settings.tools['ssh_docker'].get(key, fallback)
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 数据结构
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
@dataclass
|
||
class SSHConfig:
|
||
host: str
|
||
port: int = 22
|
||
username: str = "root"
|
||
password: str = ""
|
||
key_path: str = ""
|
||
timeout: int = 30
|
||
cmd_timeout: int = 120
|
||
|
||
@classmethod
|
||
def from_kwargs(cls, kwargs: dict) -> "SSHConfig":
|
||
"""
|
||
从调用参数构造 SSHConfig
|
||
支持通过 server 名称引用 config.yaml 中的预设
|
||
缺省值全部来自 config.yaml → tools.ssh_docker
|
||
"""
|
||
server_name = kwargs.get("server", "")
|
||
if server_name:
|
||
servers = _cfg('servers', {})
|
||
preset = servers.get(server_name)
|
||
if not preset:
|
||
raise ValueError(
|
||
f"服务器预设 '{server_name}' 未在 config.yaml "
|
||
f"tools.ssh_docker.servers 中定义\n"
|
||
f"已有预设: {list(servers.keys())}"
|
||
)
|
||
logger.info(f"📋 使用服务器预设: {server_name} → {preset.get('host')}")
|
||
return cls(
|
||
host=preset.get("host", ""),
|
||
port=int(preset.get("port", _cfg('default_ssh_port', 22))),
|
||
username=preset.get("username", _cfg('default_username', 'root')),
|
||
password=preset.get("password", ""),
|
||
key_path=preset.get("key_path", ""),
|
||
timeout=_cfg('connect_timeout', 30),
|
||
cmd_timeout=_cfg('cmd_timeout', 120),
|
||
)
|
||
|
||
return cls(
|
||
host=kwargs.get("host", ""),
|
||
port=int(kwargs.get("port", _cfg('default_ssh_port', 22))),
|
||
username=kwargs.get("username", _cfg('default_username', 'root')),
|
||
password=kwargs.get("password", ""),
|
||
key_path=kwargs.get("key_path", ""),
|
||
timeout=_cfg('connect_timeout', 30),
|
||
cmd_timeout=_cfg('cmd_timeout', 120),
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class CommandResult:
|
||
command: str
|
||
stdout: str
|
||
stderr: str
|
||
exit_code: int
|
||
success: bool = True
|
||
|
||
@property
|
||
def output(self) -> str:
|
||
return self.stdout.strip() or self.stderr.strip()
|
||
|
||
|
||
@dataclass
|
||
class DeployConfig:
|
||
image: str
|
||
container_name: str
|
||
action: str = "deploy"
|
||
ports: list[str] = field(default_factory=list)
|
||
volumes: list[str] = field(default_factory=list)
|
||
env_vars: dict[str, str] = field(default_factory=dict)
|
||
network: str = ""
|
||
restart_policy: str = ""
|
||
command: str = ""
|
||
compose_file: str = ""
|
||
pull_latest: bool = True
|
||
extra_args: str = ""
|
||
|
||
def __post_init__(self):
|
||
# 重启策略缺省值来自 config.yaml
|
||
if not self.restart_policy:
|
||
self.restart_policy = _cfg('default_restart_policy', 'unless-stopped')
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# SSH 连接管理器
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class SSHManager:
|
||
def __init__(self, cfg: SSHConfig):
|
||
self.cfg = cfg
|
||
self.client: "paramiko.SSHClient | None" = None
|
||
|
||
def connect(self) -> None:
|
||
if not _PARAMIKO_AVAILABLE:
|
||
raise RuntimeError("paramiko 未安装，请执行: pip install paramiko>=3.0.0")
|
||
|
||
self.client = paramiko.SSHClient()
|
||
self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
|
||
|
||
connect_kwargs: dict = {
|
||
"hostname": self.cfg.host,
|
||
"port": self.cfg.port,
|
||
"username": self.cfg.username,
|
||
"timeout": self.cfg.timeout,
|
||
}
|
||
if self.cfg.key_path:
|
||
logger.info(f"🔑 使用密钥认证: {self.cfg.key_path}")
|
||
connect_kwargs["key_filename"] = self.cfg.key_path
|
||
elif self.cfg.password:
|
||
logger.info("🔐 使用密码认证")
|
||
connect_kwargs["password"] = self.cfg.password
|
||
else:
|
||
logger.info("🔓 尝试 SSH Agent / 默认密钥认证")
|
||
|
||
self.client.connect(**connect_kwargs)
|
||
logger.info(
|
||
f"✅ SSH 连接成功: {self.cfg.username}@{self.cfg.host}:{self.cfg.port}\n"
|
||
f" 连接超时: {self.cfg.timeout}s "
|
||
f"[config.yaml connect_timeout={_cfg('connect_timeout')}s]\n"
|
||
f" 命令超时: {self.cfg.cmd_timeout}s "
|
||
f"[config.yaml cmd_timeout={_cfg('cmd_timeout')}s]"
|
||
)
|
||
|
||
def exec(self, command: str, timeout: int | None = None) -> CommandResult:
|
||
if not self.client:
|
||
raise RuntimeError("SSH 未连接，请先调用 connect()")
|
||
t = timeout or self.cfg.cmd_timeout
|
||
logger.debug(f"🖥 执行命令 (timeout={t}s): {command}")
|
||
|
||
_, stdout, stderr = self.client.exec_command(command, timeout=t)
|
||
exit_code = stdout.channel.recv_exit_status()
|
||
out = stdout.read().decode("utf-8", errors="replace")
|
||
err = stderr.read().decode("utf-8", errors="replace")
|
||
|
||
result = CommandResult(
|
||
command=command, stdout=out, stderr=err,
|
||
exit_code=exit_code, success=(exit_code == 0),
|
||
)
|
||
logger.debug(f" exit={exit_code} out={out[:80]} err={err[:80]}")
|
||
return result
|
||
|
||
def close(self) -> None:
|
||
if self.client:
|
||
self.client.close()
|
||
self.client = None
|
||
|
||
def __enter__(self):
|
||
self.connect()
|
||
return self
|
||
|
||
def __exit__(self, *_):
|
||
self.close()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# Docker 操作执行器
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class DockerExecutor:
|
||
ALLOWED_ACTIONS = {
|
||
"deploy", "start", "stop", "restart",
|
||
"status", "logs", "remove",
|
||
"compose_up", "compose_down", "compose_ps",
|
||
"pull", "inspect", "stats",
|
||
}
|
||
|
||
def __init__(self, ssh: SSHManager):
|
||
self.ssh = ssh
|
||
|
||
def check_docker(self) -> CommandResult:
|
||
return self.ssh.exec(
|
||
"docker --version && docker info --format '{{.ServerVersion}}'"
|
||
)
|
||
|
||
def pull_image(self, image: str) -> CommandResult:
|
||
logger.info(f"📥 拉取镜像: {image}")
|
||
return self.ssh.exec(
|
||
f"docker pull {image}",
|
||
timeout=_cfg('deploy_timeout', 300),
|
||
)
|
||
|
||
def deploy(self, cfg: DeployConfig) -> list[CommandResult]:
|
||
results = []
|
||
if cfg.pull_latest:
|
||
results.append(self.pull_image(cfg.image))
|
||
results.append(self.ssh.exec(
|
||
f"docker stop {cfg.container_name} 2>/dev/null || true"
|
||
))
|
||
results.append(self.ssh.exec(
|
||
f"docker rm {cfg.container_name} 2>/dev/null || true"
|
||
))
|
||
cmd = self._build_run_command(cfg)
|
||
logger.info(f"🚀 启动容器: {cmd}")
|
||
results.append(self.ssh.exec(cmd, timeout=_cfg('deploy_timeout', 300)))
|
||
return results
|
||
|
||
def start(self, name: str) -> CommandResult: return self.ssh.exec(f"docker start {name}")
|
||
def stop(self, name: str) -> CommandResult: return self.ssh.exec(f"docker stop {name}")
|
||
def restart(self, name: str) -> CommandResult: return self.ssh.exec(f"docker restart {name}")
|
||
|
||
def remove(self, name: str, force: bool = True) -> CommandResult:
|
||
return self.ssh.exec(f"docker rm {'-f' if force else ''} {name}")
|
||
|
||
def status(self, name: str) -> CommandResult:
|
||
cmd = (
|
||
f"docker inspect {name} "
|
||
f"--format '{{{{.Name}}}} | {{{{.State.Status}}}} | "
|
||
f"Started: {{{{.State.StartedAt}}}} | Image: {{{{.Config.Image}}}}'"
|
||
f" 2>/dev/null || echo 'Container {name} not found'"
|
||
)
|
||
return self.ssh.exec(cmd)
|
||
|
||
def logs(self, name: str, tail: int | None = None) -> CommandResult:
|
||
n = tail if tail is not None else _cfg('default_tail_lines', 100)
|
||
logger.info(
|
||
f"📋 获取日志: {name} tail={n} "
|
||
f"[config.yaml default_tail_lines={_cfg('default_tail_lines')}]"
|
||
)
|
||
return self.ssh.exec(f"docker logs --tail={n} --timestamps {name} 2>&1")
|
||
|
||
def inspect(self, name: str) -> CommandResult:
|
||
return self.ssh.exec(f"docker inspect {name}")
|
||
|
||
def stats(self, name: str) -> CommandResult:
|
||
return self.ssh.exec(
|
||
f"docker stats {name} --no-stream "
|
||
f"--format 'table {{{{.Name}}}}\t{{{{.CPUPerc}}}}\t"
|
||
f"{{{{.MemUsage}}}}\t{{{{.NetIO}}}}'"
|
||
)
|
||
|
||
def compose_up(self, compose_file: str, detach: bool = True) -> CommandResult:
|
||
work_dir = compose_file.rsplit("/", 1)[0] if "/" in compose_file else "."
|
||
logger.info(f"🐙 Compose Up: {compose_file}")
|
||
return self.ssh.exec(
|
||
f"cd {work_dir} && docker compose -f {compose_file} "
|
||
f"up {'-d' if detach else ''} --pull always",
|
||
timeout=_cfg('deploy_timeout', 300),
|
||
)
|
||
|
||
def compose_down(self, compose_file: str) -> CommandResult:
|
||
work_dir = compose_file.rsplit("/", 1)[0] if "/" in compose_file else "."
|
||
return self.ssh.exec(
|
||
f"cd {work_dir} && docker compose -f {compose_file} down"
|
||
)
|
||
|
||
def compose_ps(self, compose_file: str) -> CommandResult:
|
||
work_dir = compose_file.rsplit("/", 1)[0] if "/" in compose_file else "."
|
||
return self.ssh.exec(
|
||
f"cd {work_dir} && docker compose -f {compose_file} ps"
|
||
)
|
||
|
||
@staticmethod
|
||
def _build_run_command(cfg: DeployConfig) -> str:
|
||
"""
|
||
构造 docker run 命令
|
||
安全检查：config.yaml allow_privileged=false 时拒绝 --privileged
|
||
"""
|
||
if "--privileged" in cfg.extra_args and not _cfg('allow_privileged', False):
|
||
logger.warning(
|
||
"⚠️ 已移除 --privileged 参数\n"
|
||
" 如需启用请在 config.yaml → "
|
||
"tools.ssh_docker.allow_privileged 设置为 true"
|
||
)
|
||
cfg.extra_args = cfg.extra_args.replace("--privileged", "").strip()
|
||
|
||
parts = ["docker", "run", "-d", f"--name {cfg.container_name}"]
|
||
if cfg.restart_policy:
|
||
parts.append(f"--restart {cfg.restart_policy}")
|
||
for p in cfg.ports:
|
||
parts.append(f"-p {p}")
|
||
for v in cfg.volumes:
|
||
parts.append(f"-v {v}")
|
||
for k, val in cfg.env_vars.items():
|
||
safe_val = str(val).replace('"', '\\"')
|
||
parts.append(f'-e {k}="{safe_val}"')
|
||
if cfg.network:
|
||
parts.append(f"--network {cfg.network}")
|
||
if cfg.extra_args:
|
||
parts.append(cfg.extra_args)
|
||
parts.append(cfg.image)
|
||
if cfg.command:
|
||
parts.append(cfg.command)
|
||
return " ".join(parts)
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 主工具类
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class SSHDockerTool:
|
||
"""
|
||
SSH 远程 Docker 部署工具
|
||
所有配置均通过 settings.tools['ssh_docker'][key] 读取
|
||
"""
|
||
|
||
name = "ssh_docker"
|
||
description = (
|
||
"通过 SSH 连接到远程服务器，使用 Docker 部署和管理容器应用。"
|
||
"支持: deploy | start | stop | restart | status | logs | "
|
||
"remove | compose_up | compose_down | compose_ps | pull | inspect | stats"
|
||
)
|
||
parameters = {
|
||
"host": {
|
||
"type": "string",
|
||
"description": "远程服务器 IP 或域名（与 server 参数二选一）",
|
||
},
|
||
"server": {
|
||
"type": "string",
|
||
"description": (
|
||
"使用 config.yaml tools.ssh_docker.servers 中预设的服务器名称"
|
||
"（与 host 二选一），例如 'prod' 或 'staging'"
|
||
),
|
||
},
|
||
"username": {
|
||
"type": "string",
|
||
"description": "SSH 用户名（不传则使用 config.yaml default_username）",
|
||
},
|
||
"action": {
|
||
"type": "string",
|
||
"description": (
|
||
"Docker 操作类型: deploy（部署）| start | stop | restart | "
|
||
"status（查看状态）| logs（查看日志）| remove（删除）| "
|
||
"compose_up | compose_down | compose_ps | pull | inspect | stats"
|
||
),
|
||
"enum": sorted(DockerExecutor.ALLOWED_ACTIONS),
|
||
},
|
||
"image": {
|
||
"type": "string",
|
||
"description": "Docker 镜像名称，例如 nginx:latest（deploy/pull 时必填）",
|
||
},
|
||
"container_name": {
|
||
"type": "string",
|
||
"description": "容器名称，例如 my-nginx",
|
||
},
|
||
"port": {
|
||
"type": "integer",
|
||
"description": "SSH 端口（不传则使用 config.yaml default_ssh_port）",
|
||
},
|
||
"password": {
|
||
"type": "string",
|
||
"description": "SSH 密码（与 key_path 二选一）",
|
||
},
|
||
"key_path": {
|
||
"type": "string",
|
||
"description": "SSH 私钥路径，例如 /home/user/.ssh/id_rsa",
|
||
},
|
||
"ports": {
|
||
"type": "string",
|
||
"description": "端口映射，逗号分隔，例如 '8080:80,443:443'",
|
||
},
|
||
"volumes": {
|
||
"type": "string",
|
||
"description": "数据卷挂载，逗号分隔，例如 '/data:/app/data,/logs:/var/log'",
|
||
},
|
||
"env_vars": {
|
||
"type": "string",
|
||
"description": "环境变量 JSON 字符串，例如 '{\"DB_HOST\":\"localhost\",\"DB_PORT\":\"5432\"}'",
|
||
},
|
||
"network": {
|
||
"type": "string",
|
||
"description": "Docker 网络名称，例如 bridge 或 my-network",
|
||
},
|
||
"restart_policy": {
|
||
"type": "string",
|
||
"description": "重启策略（不传则使用 config.yaml default_restart_policy）: no | always | unless-stopped | on-failure",
|
||
},
|
||
"compose_file": {
|
||
"type": "string",
|
||
"description": "docker-compose.yml 在远程服务器上的绝对路径",
|
||
},
|
||
"pull_latest": {
|
||
"type": "boolean",
|
||
"description": "部署前是否拉取最新镜像，默认 true",
|
||
},
|
||
"tail_lines": {
|
||
"type": "integer",
|
||
"description": "查看日志时返回的行数（不传则使用 config.yaml default_tail_lines）",
|
||
},
|
||
"extra_args": {
|
||
"type": "string",
|
||
"description": "传递给 docker run 的额外参数，例如 '--memory=512m --cpus=1'",
|
||
},
|
||
}
|
||
|
||
def execute(self, **kwargs) -> str:
|
||
# ── 解析参数，缺省值全部来自 config.yaml ──────────────
|
||
action = kwargs.get("action", "status").lower()
|
||
image = kwargs.get("image", "")
|
||
container_name = kwargs.get("container_name", "")
|
||
ports_str = kwargs.get("ports", "")
|
||
volumes_str = kwargs.get("volumes", "")
|
||
env_vars_str = kwargs.get("env_vars", "{}")
|
||
network = kwargs.get("network", "")
|
||
restart_policy = kwargs.get("restart_policy", "") # 空→由 DeployConfig.__post_init__ 填充
|
||
compose_file = kwargs.get("compose_file", "")
|
||
pull_latest = bool(kwargs.get("pull_latest", True))
|
||
tail_lines_raw = kwargs.get("tail_lines", None)
|
||
tail_lines = int(tail_lines_raw) if tail_lines_raw is not None else None
|
||
extra_args = kwargs.get("extra_args", "")
|
||
|
||
logger.info(
|
||
f"🐳 SSH Docker 操作启动\n"
|
||
f" 操作 : {action}\n"
|
||
f" 容器 : {container_name or '(未指定)'}\n"
|
||
f" 镜像 : {image or '(未指定)'}\n"
|
||
f" server预设: {kwargs.get('server', '(无)')} "
|
||
f"host: {kwargs.get('host', '(无)')}\n"
|
||
f" deploy_timeout : {_cfg('deploy_timeout')}s "
|
||
f"[config.yaml]\n"
|
||
f" allow_privileged: {_cfg('allow_privileged')} "
|
||
f"[config.yaml]"
|
||
)
|
||
|
||
# ── 参数校验 ──────────────────────────────────────────
|
||
err = self._validate(kwargs, action, image, container_name, compose_file)
|
||
if err:
|
||
return err
|
||
|
||
# ── 解析复合参数 ──────────────────────────────────────
|
||
ports = [p.strip() for p in ports_str.split(",") if p.strip()]
|
||
volumes = [v.strip() for v in volumes_str.split(",") if v.strip()]
|
||
try:
|
||
env_vars: dict = json.loads(env_vars_str) if env_vars_str.strip() else {}
|
||
except json.JSONDecodeError:
|
||
return f"❌ env_vars 格式错误，请使用 JSON 格式: {env_vars_str}"
|
||
|
||
# ── 镜像黑名单检查（来自 config.yaml blocked_images）──
|
||
if image:
|
||
blocked = _cfg('blocked_images', [])
|
||
if any(image.startswith(b) for b in blocked):
|
||
return (
|
||
f"❌ 安全限制: 镜像 '{image}' 在黑名单中\n"
|
||
f" 黑名单: {blocked}\n"
|
||
f" 请在 config.yaml → tools.ssh_docker.blocked_images 中移除"
|
||
)
|
||
|
||
# ── 构造配置对象 ──────────────────────────────────────
|
||
try:
|
||
ssh_cfg = SSHConfig.from_kwargs(kwargs)
|
||
except ValueError as e:
|
||
return f"❌ SSH 配置错误: {e}"
|
||
|
||
deploy_cfg = DeployConfig(
|
||
image=image,
|
||
container_name=container_name,
|
||
action=action,
|
||
ports=ports,
|
||
volumes=volumes,
|
||
env_vars=env_vars,
|
||
network=network,
|
||
restart_policy=restart_policy,
|
||
compose_file=compose_file,
|
||
pull_latest=pull_latest,
|
||
extra_args=extra_args,
|
||
)
|
||
|
||
# ── 执行操作 ──────────────────────────────────────────
|
||
try:
|
||
with SSHManager(ssh_cfg) as ssh:
|
||
executor = DockerExecutor(ssh)
|
||
return self._dispatch(action, executor, deploy_cfg, tail_lines)
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
logger.error(f"❌ SSH Docker 操作失败: {error_msg}")
|
||
return self._format_error(action, ssh_cfg.host, error_msg)
|
||
|
||
# ── 操作分发 ──────────────────────────────────────────────
|
||
|
||
def _dispatch(
|
||
self,
|
||
action: str,
|
||
executor: DockerExecutor,
|
||
cfg: DeployConfig,
|
||
tail_lines: int | None,
|
||
) -> str:
|
||
# 先检查 Docker 环境
|
||
check = executor.check_docker()
|
||
if not check.success:
|
||
return (
|
||
f"❌ 远程服务器 Docker 不可用\n"
|
||
f" 错误: {check.stderr[:200]}\n"
|
||
f" 请确认 Docker 已安装并运行: sudo systemctl start docker"
|
||
)
|
||
|
||
match action:
|
||
case "deploy":
|
||
return self._do_deploy(executor, cfg)
|
||
case "start":
|
||
return self._fmt_single(executor.start(cfg.container_name), "start")
|
||
case "stop":
|
||
return self._fmt_single(executor.stop(cfg.container_name), "stop")
|
||
case "restart":
|
||
return self._fmt_single(executor.restart(cfg.container_name), "restart")
|
||
case "status":
|
||
return self._do_status(executor, cfg.container_name)
|
||
case "logs":
|
||
return self._do_logs(executor, cfg.container_name, tail_lines)
|
||
case "remove":
|
||
return self._fmt_single(executor.remove(cfg.container_name), "remove")
|
||
case "pull":
|
||
return self._fmt_single(executor.pull_image(cfg.image), "pull")
|
||
case "inspect":
|
||
return self._do_inspect(executor, cfg.container_name)
|
||
case "stats":
|
||
return self._fmt_single(executor.stats(cfg.container_name), "stats")
|
||
case "compose_up":
|
||
return self._fmt_single(executor.compose_up(cfg.compose_file), "compose_up")
|
||
case "compose_down":
|
||
return self._fmt_single(executor.compose_down(cfg.compose_file), "compose_down")
|
||
case "compose_ps":
|
||
return self._fmt_single(executor.compose_ps(cfg.compose_file), "compose_ps")
|
||
case _:
|
||
return f"❌ 不支持的操作: {action}"
|
||
|
||
def _do_deploy(self, executor: DockerExecutor, cfg: DeployConfig) -> str:
|
||
if cfg.compose_file:
|
||
result = executor.compose_up(cfg.compose_file)
|
||
icon = "✅" if result.success else "❌"
|
||
return (
|
||
f"{icon} Compose 部署{'成功' if result.success else '失败'}\n"
|
||
f"{'─' * 50}\n"
|
||
f" Compose 文件: {cfg.compose_file}\n"
|
||
f"{'─' * 50}\n"
|
||
f"{result.output[:1500]}"
|
||
)
|
||
results = executor.deploy(cfg)
|
||
return self._fmt_deploy(results, cfg)
|
||
|
||
def _do_status(self, executor: DockerExecutor, container_name: str) -> str:
|
||
status_r = executor.status(container_name)
|
||
stats_r = executor.stats(container_name)
|
||
lines = [
|
||
f"📊 容器状态: {container_name}",
|
||
"─" * 50,
|
||
status_r.output or "容器不存在或未运行",
|
||
]
|
||
if stats_r.success and stats_r.output:
|
||
lines += ["", "📈 资源使用:", stats_r.output]
|
||
return "\n".join(lines)
|
||
|
||
def _do_logs(
|
||
self, executor: DockerExecutor, container_name: str, tail: int | None
|
||
) -> str:
|
||
result = executor.logs(container_name, tail)
|
||
n = tail if tail is not None else _cfg('default_tail_lines', 100)
|
||
if result.success:
|
||
return (
|
||
f"📋 容器日志: {container_name} (最近 {n} 行)\n"
|
||
f"{'─' * 50}\n"
|
||
f"{result.output or '(无日志输出)'}"
|
||
)
|
||
return f"❌ 获取日志失败: {result.stderr[:300]}"
|
||
|
||
def _do_inspect(self, executor: DockerExecutor, container_name: str) -> str:
|
||
result = executor.inspect(container_name)
|
||
if result.success:
|
||
try:
|
||
data = json.loads(result.stdout)
|
||
if data:
|
||
c = data[0]
|
||
info = {
|
||
"Name": c.get("Name", ""),
|
||
"Status": c.get("State", {}).get("Status", ""),
|
||
"Image": c.get("Config", {}).get("Image", ""),
|
||
"Ports": c.get("NetworkSettings", {}).get("Ports", {}),
|
||
"Mounts": [m.get("Source") for m in c.get("Mounts", [])],
|
||
"Created": c.get("Created", ""),
|
||
}
|
||
return (
|
||
f"🔍 容器详情: {container_name}\n"
|
||
f"{'─' * 50}\n"
|
||
f"{json.dumps(info, ensure_ascii=False, indent=2)}"
|
||
)
|
||
except json.JSONDecodeError:
|
||
pass
|
||
return f"❌ 获取容器详情失败: {result.stderr[:300]}"
|
||
|
||
# ── 格式化输出 ─────────────────────────────────────────────
|
||
|
||
@staticmethod
|
||
def _fmt_deploy(results: list[CommandResult], cfg: DeployConfig) -> str:
|
||
lines = [
|
||
"🚀 容器部署结果",
|
||
"─" * 50,
|
||
f" 镜像 : {cfg.image}",
|
||
f" 容器名 : {cfg.container_name}",
|
||
f" 端口 : {', '.join(cfg.ports) or '(无)'}",
|
||
f" 数据卷 : {', '.join(cfg.volumes) or '(无)'}",
|
||
f" 重启策略: {cfg.restart_policy} "
|
||
f"[config.yaml default_restart_policy="
|
||
f"{_cfg('default_restart_policy')}]",
|
||
"─" * 50,
|
||
]
|
||
all_ok = True
|
||
for r in results:
|
||
icon = "✅" if r.success else "❌"
|
||
lines.append(f" {icon} $ {r.command[:70]}")
|
||
if r.output:
|
||
lines.append(f" └─ {r.output[:150]}")
|
||
if not r.success:
|
||
all_ok = False
|
||
lines.append(f" └─ 错误: {r.stderr[:150]}")
|
||
lines.append("─" * 50)
|
||
lines.append(
|
||
f"✅ 部署成功！容器 [{cfg.container_name}] 已启动"
|
||
if all_ok else
|
||
"⚠️ 部署过程中有步骤失败，请检查上方错误信息"
|
||
)
|
||
return "\n".join(lines)
|
||
|
||
@staticmethod
|
||
def _fmt_single(result: CommandResult, action: str) -> str:
|
||
icon = "✅" if result.success else "❌"
|
||
status = "成功" if result.success else "失败"
|
||
return (
|
||
f"{icon} {action} {status}\n"
|
||
f"{'─' * 40}\n"
|
||
f"{result.output[:500] or '(无输出)'}"
|
||
)
|
||
|
||
@staticmethod
|
||
def _format_error(action: str, host: str, error: str) -> str:
|
||
lines = [
|
||
f"❌ SSH Docker [{action}] 操作失败",
|
||
"─" * 50,
|
||
f" 服务器: {host}",
|
||
f" 错误 : {error}",
|
||
"─" * 50,
|
||
"💡 排查建议:",
|
||
]
|
||
el = error.lower()
|
||
if "authentication" in el or "auth" in el:
|
||
lines += [
|
||
" • 检查用户名/密码是否正确",
|
||
" • 检查 SSH 密钥路径和权限（chmod 600 ~/.ssh/id_rsa）",
|
||
" • 或在 config.yaml tools.ssh_docker.servers 中配置预设",
|
||
]
|
||
elif "connection" in el or "timed out" in el:
|
||
lines += [
|
||
" • 检查服务器 IP 和 SSH 端口是否正确",
|
||
" • 检查防火墙是否开放 SSH 端口",
|
||
f" • config.yaml connect_timeout={_cfg('connect_timeout')}s，可适当增大",
|
||
]
|
||
elif "docker" in el:
|
||
lines += [
|
||
" • 确认 Docker 已安装: docker --version",
|
||
" • 确认 Docker 服务运行: sudo systemctl start docker",
|
||
" • 确认用户有 Docker 权限: sudo usermod -aG docker $USER",
|
||
]
|
||
return "\n".join(lines)
|
||
|
||
# ── 参数校验 ──────────────────────────────────────────────
|
||
|
||
@staticmethod
|
||
def _validate(
|
||
kwargs: dict,
|
||
action: str,
|
||
image: str,
|
||
container_name: str,
|
||
compose_file: str,
|
||
) -> str | None:
|
||
# 必须提供 host 或 server 之一
|
||
if not kwargs.get("host") and not kwargs.get("server"):
|
||
return "❌ 参数错误: 必须提供 host（服务器地址）或 server（预设名称）之一"
|
||
|
||
if action not in DockerExecutor.ALLOWED_ACTIONS:
|
||
return (
|
||
f"❌ 不支持的操作: {action}\n"
|
||
f" 可选值: {', '.join(sorted(DockerExecutor.ALLOWED_ACTIONS))}"
|
||
)
|
||
|
||
# 主机白名单检查（来自 config.yaml allowed_hosts）
|
||
host = kwargs.get("host", "")
|
||
allowed_hosts = _cfg('allowed_hosts', [])
|
||
if host and allowed_hosts and host not in allowed_hosts:
|
||
return (
|
||
f"❌ 安全限制: 服务器 '{host}' 不在白名单中\n"
|
||
f" 白名单: {allowed_hosts}\n"
|
||
f" 请在 config.yaml → tools.ssh_docker.allowed_hosts 中添加"
|
||
)
|
||
|
||
if action == "deploy" and not image and not compose_file:
|
||
return "❌ deploy 操作需要指定 image（镜像名）或 compose_file（Compose 文件路径）"
|
||
|
||
needs_container = {
|
||
"start", "stop", "restart", "logs", "remove", "inspect", "stats"
|
||
}
|
||
if action in needs_container and not container_name:
|
||
return f"❌ {action} 操作需要指定 container_name（容器名称）"
|
||
|
||
needs_compose = {"compose_up", "compose_down", "compose_ps"}
|
||
if action in needs_compose and not compose_file:
|
||
return f"❌ {action} 操作需要指定 compose_file（docker-compose.yml 路径）"
|
||
|
||
return None |