udeServer/internal/logic/updateservicelogic.go

// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.2

package logic

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"path"
	"strings"

	"udeServer/internal/apierr"
	"udeServer/internal/audit"
	"udeServer/internal/model"
	"udeServer/internal/svc"
	"udeServer/internal/types"

	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

type UpdateServiceLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewUpdateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateServiceLogic {
	return &UpdateServiceLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *UpdateServiceLogic) UpdateService(req *types.UpdateServiceReq) (*types.ServiceResp, error) {
	if err := checkId(req.Id); err != nil {
		return nil, err
	}
	// 查旧实体:换密钥校验需要旧的 mount_status/key_iden;
	// 目录联动需要旧目录清单(算差集,决定哪些目录要去外挂程序卸载)
	svc, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id)
	if err != nil {
		return nil, err
	}

	// B 方案硬校验:挂载中的服务禁止更换密钥。
	// 原因:FUSE 实际挂载仍用【旧密钥】解密,库里 keyIden 换成新的会形成"记新挂旧"的
	// 脏状态,后续任何按库里 keyIden 进行的重挂/刷库都会用错密钥 → 旧密文读成乱码。
	// 正规路径:卸载 → 用旧密钥解密存量 → 新密钥重加密(刷库) → 新密钥重新挂载。
	if svc.MountStatus.String == "mounted" && req.KeyIden != svc.KeyIden.String {
		return nil, apierr.BadRequest("服务正在挂载中,禁止更换密钥;请先卸载后再操作")
	}

	// 旧目录清单:联动卸载的依据(哪些目录被移除了,才需要去外挂程序卸载)
	oldDirs, err := l.svcCtx.DirectoryModel.FindDirsByServiceId(l.ctx, req.Id)
	if err != nil {
		l.Errorf("query old directories of service %d failed: %v", req.Id, err)
		return nil, err
	}

	// 新目录清单规范化:trim 去空白 + path.Clean(发给 Linux 外挂必须保持 / 分隔符) + 去重
	newDirs := make([]string, 0, len(req.Directories))
	for _, dir := range req.Directories {
		dir = strings.TrimSpace(dir)
		if dir == "" {
			continue
		}
		newDirs = append(newDirs, path.Clean(dir))
	}
	newDirs = dedupStrings(newDirs)

	// 挂载联动(事务前软处理):只有带 directories 字段的请求(编辑弹窗)才触发;
	// changeStatus 状态开关等不传 directories 的调用方完全不受影响,状态保持原值。
	// 联动失败绝不阻塞保存,失败信息聚合成 mountWarning 由前端弹黄色警告。
	mountWarning := ""
	mountStatus := svc.MountStatus.String // 无联动动作时,Update 原样写回旧值
	if req.Directories != nil {
		mountWarning, mountStatus = l.applyMountChanges(svc, oldDirs, newDirs, req)
	}

	// 编辑联动失败时,服务状态与挂载结果强绑定(与新增服务同规则):
	// 挂载/卸载任一失败 → mount_status=failed 且 status 同步置"停用",
	// 避免"启用+failed"的错位组合;req.Directories==nil 的调用方(状态开关)不受影响。
	finalStatus := req.Status
	if req.Directories != nil && mountStatus == "failed" {
		finalStatus = "停用"
	}

	// 事务:更新服务 + 目录全删全插(与新增服务同款后端收口模式,任一步失败整体回滚)
	err = l.svcCtx.DB.Transact(func(session sqlx.Session) error {
		svcModel := l.svcCtx.ServiceModel.WithSession(session)
		dirModel := l.svcCtx.DirectoryModel.WithSession(session)

		data := &model.TService{
			Id:          req.Id,
			Name:        nullString(req.Name),
			Ip:          nullString(req.Ip),
			Port:        req.Port, // 端口 int 类型,int64 直传(0=未配置)
			Iden:        nullString(req.Iden),
			KeyIden:     nullString(req.KeyIden),
			KeyAlgo:     nullString(req.KeyAlgo),
			Status:      nullString(finalStatus),
			MountStatus: nullString(mountStatus), // 联动算出的新状态(没联动就是旧值)
			Brush:       req.Brush,               // 一键刷库配置:编辑只落库改配置,不追溯触发刷库(刷库编排仅在创建流程)
		}
		if err := svcModel.Update(l.ctx, data); err != nil {
			return fmt.Errorf("update t_service %d: %w", req.Id, err)
		}

		// 目录三态:nil = 不动目录(状态开关等场景);空数组 = 清空;非空 = 全量重写
		if req.Directories != nil {
			if err := dirModel.DeleteByServiceId(l.ctx, req.Id); err != nil {
				return fmt.Errorf("delete old directories of service %d: %w", req.Id, err)
			}
			for _, dir := range newDirs {
				if _, err := dirModel.Insert(l.ctx, &model.TDirectory{
					ServiceId: nullInt64(req.Id),
					Directory: nullString(dir),
				}); err != nil {
					return fmt.Errorf("insert t_directory[%s]: %w", dir, err)
				}
			}
		}
		return nil
	})
	if err != nil {
		l.Errorf("update service tx failed: %v", err)
		return nil, err
	}

	updated, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id)
	if err != nil {
		return nil, err
	}

	resp := toServiceResp(updated)
	if mountWarning != "" {
		resp.MountWarning = mountWarning // 联动有失败时前端弹黄色警告
	}
	return resp, nil
}

// ======== 编辑联动挂载的辅助方法 ========

// applyMountChanges 编辑保存时的挂载联动:对比新旧目录,该卸的卸、该挂的挂。
// 联动在【事务之前】执行且全程软处理:任何失败只聚合成警告文案,绝不阻塞保存。
// 幂等复用:新目录全量下发挂载,外挂的幂等决策表会自动跳过"已挂且同密钥"的目录,
// 顺带把 failed 服务漏挂的目录也补挂上(自愈)。
// 返回:warning(空串 = 联动全部成功), newStatus(联动后应写入库的 mount_status)。
func (l *UpdateServiceLogic) applyMountChanges(svc *model.TService, oldDirs, newDirs []string, req *types.UpdateServiceReq) (string, string) {
	// IP/端口变了 = 外挂换机器了:旧机器上的挂载全部要卸,新机器全量重挂
	ipChanged := req.Ip != svc.Ip.String || req.Port != svc.Port // port 已是 int64,直接数值比较

	// 该卸载的清单:换 IP → 全卸;没换 IP → 只卸"被移除"的目录(差集 old-new)
	var toUnmount []string
	if ipChanged {
		toUnmount = oldDirs
	} else {
		toUnmount = diffStrings(oldDirs, newDirs)
	}

	// 已挂载(mounted)的服务编辑时不重新触发挂载:剩余目录仍挂在外挂上,
	// 重发挂载请求只是白跑一趟幂等检查;若外挂恰好不可达或鉴权不匹配,
	// 反而会把好端端的 mounted 服务打成 failed。需要补挂/换机重挂时,
	// 走列表开关"停用(卸载)→启用(挂载)"的正规路径。
	needMount := svc.MountStatus.String != "mounted"

	var msgs []string
	// 1. 先卸载(清理动作,已挂载服务也保留):发往【旧】IP(挂载记录登记在旧机器的外挂程序进程里)
	if len(toUnmount) > 0 {
		oldIp, oldPort := svc.Ip.String, svc.Port // port 已是 int64
		if oldIp == "" || oldPort == 0 {
			msgs = append(msgs, "原外挂 IP/端口为空,无法联动卸载,旧目录可能仍处于挂载状态")
		} else {
			for _, dir := range toUnmount {
				// 卸载发往旧机器,用旧 iden 作 X-TOKEN(旧机器的外挂 TOKEN 按旧值配置)
				if w := l.fuseUnmountOne(svc.Iden.String, oldIp, oldPort, dir); w != "" {
					msgs = append(msgs, w)
				}
			}
		}
	}

	// 2. 再挂载:仅未挂载(unmounted/failed)的服务才全量下发,
	//    幂等表自动跳过已挂的目录,顺带把 failed 服务漏挂的目录补挂上(自愈)。
	if needMount && len(newDirs) > 0 {
		if req.Ip == "" || req.Port == 0 {
			msgs = append(msgs, "新外挂 IP/端口为空,无法联动挂载")
		} else {
			ikey, err := l.lookupIkey(req.KeyIden)
			if err != nil {
				msgs = append(msgs, fmt.Sprintf("联动挂载失败: %v", err))
			} else {
				for _, dir := range newDirs {
					// 挂载发往新机器,用新 iden 作 X-TOKEN(新机器的外挂 TOKEN 按新值配置)
					if w := l.fuseMountOne(req.Iden, req.Ip, req.Port, dir, ikey); w != "" {
						msgs = append(msgs, w)
					}
				}
			}
		}
	}

	// 3. mount_status 重算:
	//    任一动作失败 → failed(同时返回聚合警告,主流程会把 status 一并置"停用");
	//    未挂载服务走了挂载 → 全成功有目录 = mounted,清空目录 = unmounted;
	//    已挂载服务(未重新挂载)→ 换机全卸了 = unmounted,否则剩余目录仍挂着 = 保持 mounted。
	if len(msgs) > 0 {
		return "编辑已保存,但挂载联动存在失败: " + strings.Join(msgs, "; "), "failed"
	}
	if needMount {
		if len(newDirs) > 0 {
			return "", "mounted"
		}
		return "", "unmounted"
	}
	if ipChanged && len(toUnmount) > 0 {
		return "", "unmounted" // 换机把旧挂载全卸了,新机器上没有挂载
	}
	return "", svc.MountStatus.String
}

// fuseMountOne 通知外挂程序挂载单个目录。成功返回空串,失败返回警告文案。
// 请求体与新增服务完全同款:{backing: 目录+"-cipher", mount: 目录, ikey: 密钥内容}
func (l *UpdateServiceLogic) fuseMountOne(iden, ip string, port int64, mount, ikey string) string {
	// path.Clean(非 filepath!):路径要发给远程 Linux 外挂程序,必须保持 / 分隔符
	dirLinuxPath := path.Clean(mount)
	payload := map[string]interface{}{
		"backing": dirLinuxPath + "-cipher", // 密文目录 = 保护目录 + "-cipher" 后缀
		"mount":   dirLinuxPath,             // 挂载点 = 保护目录本身
		"ikey":    ikey,
	}
	body, err := json.Marshal(payload)
	if err != nil {
		return fmt.Sprintf("序列化挂载请求失败: %v", err)
	}
	baseURL := fmt.Sprintf("http://%s:%d/api/fuseMount", ip, port) // %d:port 是 int64
	// DoSimple 记录 type=2 接口日志,父 Span 指向本次入站请求
	if _, callErr := audit.DoSimple(l.svcCtx.SpanRecorder, l.ctx, "FuseMount", baseURL, body,
		func() (map[string]interface{}, int64, error) {
			// doFuseRequest 注入 X-TOKEN=iden(接入标识);client.Post 快捷方式带不了自定义头,裸发会被外挂 401 拒绝
			resp, rerr := doFuseRequest(fuseMountClient, iden, http.MethodPost, baseURL, bytes.NewReader(body), "application/json")
			if rerr != nil {
				return nil, 0, fmt.Errorf("挂载目录 %s 失败(外挂程序未启动?): %w", dirLinuxPath, rerr)
			}
			raw, _ := io.ReadAll(resp.Body) // 读到 EOF 保证 TCP 连接复用 Keep-Alive
			resp.Body.Close()
			status := int64(resp.StatusCode)
			if status >= http.StatusBadRequest {
				return nil, status, fmt.Errorf("挂载目录 %s 失败,外挂程序返回 HTTP %d: %s", dirLinuxPath, status, string(raw))
			}
			return map[string]interface{}{"status": status, "body": string(raw)}, status, nil
		}); callErr != nil {
		return callErr.Error()
	}
	l.Infof("fuse mount ok: %s -> %s", dirLinuxPath, dirLinuxPath+"-cipher")
	return ""
}

// fuseUnmountOne 通知外挂程序卸载单个挂载点。成功返回空串,失败返回警告文案。
// 卸载接口幂等:挂载点不在外挂注册表中也返回成功,所以重存/多卸都零成本。
func (l *UpdateServiceLogic) fuseUnmountOne(iden, ip string, port int64, mount string) string {
	cleanMount := path.Clean(mount)                                  // 同上,发给 Linux 必须保持 / 分隔符
	baseURL := fmt.Sprintf("http://%s:%d/api/fuseUnMount", ip, port) // %d:port 是 int64
	reqURL, uerr := url.Parse(baseURL)
	if uerr != nil {
		return fmt.Sprintf("解析 URL 失败: %v", uerr)
	}
	q := reqURL.Query()
	q.Set("mount", cleanMount) // q.Encode() 自动做 URL 编码(/ → %2F),外挂侧 Query().Get 自动解码还原
	finalURL := reqURL.String()
	// DoSimple 记录 type=2 接口日志,父 Span 指向本次入站请求(GET 请求用 url 描述请求原文)
	if _, callErr := audit.DoSimple(l.svcCtx.SpanRecorder, l.ctx, "FuseUnMount", finalURL,
		audit.BuildRemoteGetRequest(http.MethodGet, finalURL),
		func() (map[string]interface{}, int64, error) {
			// doFuseRequest 注入 X-TOKEN=iden(接入标识);client.Get 快捷方式带不了自定义头,裸发会被外挂 401 拒绝
			resp, rerr := doFuseRequest(fuseMountClient, iden, http.MethodGet, finalURL, nil, "")
			if rerr != nil {
				return nil, 0, fmt.Errorf("卸载目录 %s 失败(外挂程序未启动?): %w", cleanMount, rerr)
			}
			raw, _ := io.ReadAll(resp.Body) // 读到 EOF 保证 TCP 连接复用 Keep-Alive
			resp.Body.Close()
			status := int64(resp.StatusCode)
			if status >= http.StatusBadRequest {
				return nil, status, fmt.Errorf("卸载目录 %s 失败,外挂程序返回 HTTP %d: %s", cleanMount, status, string(raw))
			}
			return map[string]interface{}{"status": status, "body": string(raw)}, status, nil
		}); callErr != nil {
		return callErr.Error()
	}
	l.Infof("fuse unmount ok: %s", cleanMount)
	return ""
}

// lookupIkey 按密钥标识(keyIden)查密钥内容,下发挂载时作为 ikey 使用。
// 独立成方法供编辑联动复用,不动 createservicelogic.go 的原有实现。
func (l *UpdateServiceLogic) lookupIkey(keyIden string) (string, error) {
	if keyIden == "" {
		return "", fmt.Errorf("服务未配置密钥标识(keyIden),无法下发挂载")
	}
	key, err := l.svcCtx.KeyModel.FindOneByIden(l.ctx, keyIden)
	if err != nil {
		return "", fmt.Errorf("查询密钥(%s)失败: %w", keyIden, err)
	}
	ikey := key.Content.String
	if ikey == "" {
		return "", fmt.Errorf("密钥(%s)内容为空,无法下发挂载", keyIden)
	}
	return ikey, nil
}

// diffStrings 集合差集:返回"在 oldDirs 中但不在 newDirs 中"的元素(被移除的目录)。
func diffStrings(oldDirs, newDirs []string) []string {
	// map[string]bool 当集合用:value 只存 true/false,判断"存在性"是 O(1)
	newSet := make(map[string]bool, len(newDirs))
	for _, v := range newDirs {
		newSet[v] = true
	}
	out := make([]string, 0, len(oldDirs))
	for _, v := range oldDirs {
		if !newSet[v] {
			out = append(out, v)
		}
	}
	return out
}

// dedupStrings 保序去重:同一路径提交两次只落库/下发一次。
func dedupStrings(in []string) []string {
	seen := make(map[string]bool, len(in))
	out := make([]string, 0, len(in))
	for _, v := range in {
		if seen[v] {
			continue // 已见过,跳过
		}
		seen[v] = true
		out = append(out, v)
	}
	return out
}