feat(k8s): M2 Pod Metrics 详情页接入 — ListPods 注入 metrics

后端: - 新增 buildPodMetricsMap() 公共辅助函数，聚合多容器 CPU/Memory - ListPods / listPodsWithNS / ListPodsAllNS 三个 handler 全部注入 - PodSummary 增加 cpu_usage_m / mem_usage_mi 字段前端: - KubernetesWorkloads Pod 表格增加 CPU/内存列 - NamespaceResourcePage Pod 表格增加 CPU/内存列验证: - 17 个 Pod 全部返回真实 metrics (argocd/demo-jar) - curl /kubernetes-clusters/1/pods → cpu_usage_m='2m' mem_usage_mi='61Mi' 文档: - ROADMAP M1→done, M2→done, 验收标准全部勾选 - TDD_PLAN M2 通过标准补充 - PROJECT_EVALUATION P0 缺失项移除
2026-06-23 00:54:54 +08:00
1 parent 8c272a6fa6
commit 4f1ffd1275
@@ -0,0 +1,336 @@
+package toolinstaller
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"ezops/internal/models"
+
+	"gorm.io/gorm"
+)
+
+// ToolInstaller handles lazy installation of devops tools.
+// Each tool gets a sync.Once to prevent concurrent installations.
+type ToolInstaller struct {
+	db     *gorm.DB
+	onces  map[string]*sync.Once
+	mu     sync.Mutex
+}
+
+// New creates a ToolInstaller.
+func New(db *gorm.DB) *ToolInstaller {
+	return &ToolInstaller{
+		db:    db,
+		onces: make(map[string]*sync.Once),
+	}
+}
+
+// ensureOnce returns a sync.Once for the given tool name.
+func (ti *ToolInstaller) ensureOnce(name string) *sync.Once {
+	ti.mu.Lock()
+	defer ti.mu.Unlock()
+	if o, ok := ti.onces[name]; ok {
+		return o
+	}
+	o := &sync.Once{}
+	ti.onces[name] = o
+	return o
+}
+
+// EnsureAvailable checks if a tool is available and installs it if configured for lazy loading.
+// Returns nil if the tool is ready, or an error if installation failed.
+func (ti *ToolInstaller) EnsureAvailable(toolName string) error {
+	// Find tool in DB
+	var tool models.DeployTool
+	if err := ti.db.Where("name = ?", toolName).First(&tool).Error; err != nil {
+		// Tool not in DB — try to find it by path
+		if _, lookErr := exec.LookPath(toolName); lookErr == nil {
+			return nil // available even without DB config
+		}
+		return fmt.Errorf("tool %s not configured in DB", toolName)
+	}
+
+	if !tool.Enabled {
+		return fmt.Errorf("tool %s is disabled", toolName)
+	}
+
+	// Check if already installed
+	if tool.InstallMethod == models.ToolPreinstall || tool.InstallMethod == models.ToolLazy {
+		if inst, err := ti.checkInstalled(tool); err == nil {
+			// Update status if needed
+			if tool.Status != models.ToolInstalled {
+				ti.updateStatus(tool.ID, models.ToolInstalled, inst, "")
+			}
+			return nil
+		}
+	}
+
+	switch tool.InstallMethod {
+	case models.ToolPreinstall:
+		return fmt.Errorf("tool %s should be preinstalled but not found", toolName)
+	case models.ToolDisabled:
+		return fmt.Errorf("tool %s is disabled", toolName)
+	case models.ToolLazy:
+		// Use sync.Once to prevent concurrent installs
+		var installErr error
+		once := ti.ensureOnce(toolName)
+		once.Do(func() {
+			installErr = ti.installTool(&tool)
+		})
+		// If install failed, reset the Once so next call can retry
+		if installErr != nil {
+			ti.mu.Lock()
+			delete(ti.onces, toolName)
+			ti.mu.Unlock()
+		}
+		return installErr
+	default:
+		return fmt.Errorf("unknown install method: %s", tool.InstallMethod)
+	}
+}
+
+// checkInstalled runs the tool's check command and returns the version string.
+func (ti *ToolInstaller) checkInstalled(tool models.DeployTool) (string, error) {
+	// First try LookPath
+	if tool.BinaryName != "" {
+		if _, err := exec.LookPath(tool.BinaryName); err != nil {
+			return "", fmt.Errorf("binary %s not found", tool.BinaryName)
+		}
+	}
+
+	// Run check command if provided
+	if tool.CheckCommand != "" {
+		cmd := exec.Command("sh", "-c", tool.CheckCommand)
+		out, err := cmd.Output()
+		if err != nil {
+			return "", err
+		}
+		return strings.TrimSpace(strings.Split(string(out), "\n")[0]), nil
+	}
+
+	return "unknown", nil
+}
+
+// installTool performs the actual installation.
+func (ti *ToolInstaller) installTool(tool *models.DeployTool) error {
+	log.Printf("[ToolInstaller] Installing %s (method=%s)...", tool.Name, tool.InstallMethod)
+
+	// Mark as installing
+	ti.updateStatus(tool.ID, models.ToolInstalling, "", "")
+
+	var err error
+	if tool.InstallScript != "" {
+		err = ti.runInstallScript(tool)
+	} else if tool.DownloadURL != "" {
+		err = ti.downloadBinary(tool)
+	} else {
+		err = fmt.Errorf("no install script or download URL configured for %s", tool.Name)
+	}
+
+	if err != nil {
+		errMsg := err.Error()
+		log.Printf("[ToolInstaller] ERROR installing %s: %s", tool.Name, errMsg)
+		ti.updateStatus(tool.ID, models.ToolFailed, "", errMsg)
+		return fmt.Errorf("failed to install %s: %w", tool.Name, err)
+	}
+
+	// Verify installation
+	ver, checkErr := ti.checkInstalled(*tool)
+	if checkErr != nil {
+		log.Printf("[ToolInstaller] WARNING: %s installed but check failed: %v", tool.Name, checkErr)
+		ti.updateStatus(tool.ID, models.ToolInstalled, "unknown", "")
+	} else {
+		log.Printf("[ToolInstaller] %s installed successfully: %s", tool.Name, ver)
+		ti.updateStatus(tool.ID, models.ToolInstalled, ver, "")
+	}
+
+	return nil
+}
+
+// runInstallScript executes the tool's install script in a subshell.
+func (ti *ToolInstaller) runInstallScript(tool *models.DeployTool) error {
+	// Write script to temp file
+	tmpFile, err := os.CreateTemp("", fmt.Sprintf("tool-install-%s-*.sh", tool.Name))
+	if err != nil {
+		return fmt.Errorf("cannot create temp script: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	version := tool.DefaultVersion
+	if version == "" {
+		version = "latest"
+	}
+
+	script := fmt.Sprintf("#!/bin/sh\nset -e\nTOOL_VERSION=%s\n%s\n", version, tool.InstallScript)
+	if _, err := tmpFile.WriteString(script); err != nil {
+		return fmt.Errorf("cannot write temp script: %w", err)
+	}
+	tmpFile.Close()
+	os.Chmod(tmpFile.Name(), 0755)
+
+	cmd := exec.Command("sh", tmpFile.Name())
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+// downloadBinary downloads a binary file to the install path.
+// Uses multi-mirror fallback: tries each mirror URL in order, with HEAD verification
+// to skip dead mirrors before attempting a full download.
+func (ti *ToolInstaller) downloadBinary(tool *models.DeployTool) error {
+	version := tool.DefaultVersion
+	if version == "" {
+		// Try to get latest version
+		if tool.VersionURL != "" {
+			v, err := ti.fetchVersion(tool.VersionURL)
+			if err != nil {
+				log.Printf("[ToolInstaller] WARNING: cannot fetch version for %s: %v, using default", tool.Name, err)
+			} else {
+				version = v
+			}
+		}
+	}
+	if version == "" {
+		version = "latest"
+	}
+
+	// Resolve mirror URLs — domestic mirrors prioritized when in China
+	mirrorURLs := GetMirrorsForTool(tool.Name, tool.DownloadURL)
+	if len(mirrorURLs) == 0 {
+		return fmt.Errorf("no download URLs configured for %s", tool.Name)
+	}
+
+	// Try each mirror in order
+	var lastErr error
+	for i, urlTemplate := range mirrorURLs {
+		url := strings.ReplaceAll(urlTemplate, "{version}", version)
+		log.Printf("[ToolInstaller] Downloading %s from mirror[%d]: %s", tool.Name, i, url)
+
+		err := ti.tryDownload(url, tool)
+		if err == nil {
+			return nil // success
+		}
+		lastErr = err
+		log.Printf("[ToolInstaller] Mirror[%d] failed for %s: %v, trying next...", i, tool.Name, err)
+	}
+
+	return fmt.Errorf("all %d mirrors exhausted for %s, last error: %w", len(mirrorURLs), tool.Name, lastErr)
+}
+
+// tryDownload attempts a single download from a URL.
+func (ti *ToolInstaller) tryDownload(url string, tool *models.DeployTool) error {
+	// Use a client with timeout for the download phase.
+	// Large files (kubectl ~50MB) can take minutes on slow networks.
+	client := &http.Client{Timeout: 30 * time.Minute}
+	resp, err := client.Get(url)
+	if err != nil {
+		return fmt.Errorf("download failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download returned HTTP %d", resp.StatusCode)
+	}
+
+	// Write to temp file first, then rename (atomic-ish)
+	installPath := tool.InstallPath
+	if installPath == "" {
+		installPath = filepath.Join("/usr/local/bin", tool.BinaryName)
+	}
+
+	dir := filepath.Dir(installPath)
+	tmpFile, err := os.CreateTemp(dir, fmt.Sprintf(".%s-download-*", tool.Name))
+	if err != nil {
+		return fmt.Errorf("cannot create temp file: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := io.Copy(tmpFile, resp.Body); err != nil {
+		tmpFile.Close()
+		return fmt.Errorf("failed to save download: %w", err)
+	}
+	tmpFile.Close()
+
+	os.Chmod(tmpFile.Name(), 0755)
+
+	if err := os.Rename(tmpFile.Name(), installPath); err != nil {
+		// Fallback: copy
+		data, _ := os.ReadFile(tmpFile.Name())
+		if writeErr := os.WriteFile(installPath, data, 0755); writeErr != nil {
+			return fmt.Errorf("cannot move binary to %s: %w", installPath, writeErr)
+		}
+	}
+
+	return nil
+}
+
+// fetchVersion gets the latest version string from a URL.
+func (ti *ToolInstaller) fetchVersion(url string) (string, error) {
+	client := &http.Client{Timeout: 15 * time.Second}
+	resp, err := client.Get(url)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 256))
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(body)), nil
+}
+
+// updateStatus updates the tool's status in the database.
+func (ti *ToolInstaller) updateStatus(toolID uint, status models.ToolStatus, version string, errMsg string) {
+	now := time.Now()
+	updates := map[string]interface{}{
+		"status":    status,
+		"last_check": &now,
+	}
+	if version != "" {
+		updates["installed_version"] = version
+	}
+	if errMsg != "" {
+		updates["error_msg"] = errMsg
+	}
+	ti.db.Model(&models.DeployTool{}).Where("id = ?", toolID).Updates(updates)
+}
+
+// SeedTools inserts predefined tools into the database if the table is empty.
+func (ti *ToolInstaller) SeedTools() {
+	var count int64
+	ti.db.Model(&models.DeployTool{}).Count(&count)
+	if count > 0 {
+		return
+	}
+
+	tools := models.PredefinedTools()
+	now := time.Now()
+	for i := range tools {
+		tools[i].CreatedAt = now
+		tools[i].UpdatedAt = now
+		// Check if preinstalled tools are actually available
+		if tools[i].InstallMethod == models.ToolPreinstall {
+			if ver, err := ti.checkInstalled(tools[i]); err == nil {
+				tools[i].Status = models.ToolInstalled
+				tools[i].InstalledVer = ver
+			} else {
+				tools[i].Status = models.ToolNotInstalled
+			}
+		}
+	}
+
+	if err := ti.db.Create(&tools).Error; err != nil {
+		log.Printf("[ToolInstaller] Seed failed: %v", err)
+	} else {
+		log.Printf("[ToolInstaller] Seeded %d tools", len(tools))
+	}
+}