初版功能完成

cmd/engineer/app_windows.go

@@ -0,0 +1,333 @@
+//go:build windows
+
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/netip"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+
+	"remlink/internal/localization"
+	"remlink/internal/model"
+	"remlink/internal/nodeagent"
+	"remlink/internal/protocol"
+	sessionruntime "remlink/internal/session"
+	"remlink/internal/siteprofile"
+)
+
+type EngineerApp struct {
+	mu       sync.RWMutex
+	ctx      context.Context
+	cancel   context.CancelFunc
+	options  nodeagent.Options
+	engine   *sessionruntime.EngineerRuntime
+	profiles *siteprofile.Store
+	state    EngineerState
+}
+
+type EngineerState struct {
+	ServerConnected  bool                   `json:"serverConnected"`
+	ControlConnected bool                   `json:"controlConnected"`
+	ServerURL        string                 `json:"serverURL"`
+	Version          string                 `json:"version"`
+	OverlayIP        string                 `json:"overlayIP"`
+	Sites            []protocol.SiteSummary `json:"sites"`
+	SiteCIDRs        map[string][]string    `json:"siteCIDRs"`
+	Session          EngineerSessionState   `json:"session"`
+	Logs             []EngineerLog          `json:"logs"`
+}
+
+type EngineerSessionState struct {
+	ID              string     `json:"id"`
+	SiteName        string     `json:"siteName"`
+	CIDRs           []string   `json:"cidrs"`
+	Status          string     `json:"status"`
+	UploadBytes     uint64     `json:"uploadBytes"`
+	DownloadBytes   uint64     `json:"downloadBytes"`
+	UploadPackets   uint64     `json:"uploadPackets"`
+	DownloadPackets uint64     `json:"downloadPackets"`
+	LatencyMS       int        `json:"latencyMS"`
+	StartedAt       *time.Time `json:"startedAt,omitempty"`
+	Reason          string     `json:"reason,omitempty"`
+}
+
+type EngineerLog struct {
+	Time    time.Time `json:"time"`
+	Level   string    `json:"level"`
+	Message string    `json:"message"`
+}
+
+func NewEngineerApp(options nodeagent.Options, profiles *siteprofile.Store) *EngineerApp {
+	return &EngineerApp{options: options, profiles: profiles, state: EngineerState{
+		ServerURL: options.ServerURL, Version: options.Version,
+		Sites: []protocol.SiteSummary{}, SiteCIDRs: map[string][]string{}, Logs: []EngineerLog{},
+		Session: EngineerSessionState{CIDRs: []string{}, Status: "IDLE"},
+	}}
+}
+
+func (a *EngineerApp) CheckCIDRs(cidrs []string) error {
+	a.mu.RLock()
+	engine := a.engine
+	a.mu.RUnlock()
+	if engine == nil {
+		return errors.New("Engineer 网络运行时尚未就绪")
+	}
+	return engine.PreflightCIDRs(cidrs)
+}
+
+func (a *EngineerApp) Startup(wailsContext context.Context) {
+	a.mu.Lock()
+	a.ctx, a.cancel = context.WithCancel(wailsContext)
+	ctx := a.ctx
+	a.mu.Unlock()
+	if a.profiles != nil {
+		profiles, err := a.profiles.Load()
+		if err != nil {
+			a.appendLog("ERROR", "读取现场网段配置失败："+err.Error())
+		} else {
+			a.mu.Lock()
+			for siteID, profile := range profiles {
+				a.state.SiteCIDRs[siteID] = append([]string(nil), profile.CIDRs...)
+			}
+			a.mu.Unlock()
+		}
+	}
+	options := a.options
+	options.OnOverlayReady = func(address netip.Addr) {
+		a.mu.Lock()
+		a.state.ServerConnected = true
+		a.state.OverlayIP = address.String()
+		a.mu.Unlock()
+		a.appendLog("INFO", "Overlay 已就绪："+address.String())
+		a.emit()
+	}
+	options.OnControlState = func(connected bool) {
+		a.mu.Lock()
+		a.state.ControlConnected = connected
+		a.mu.Unlock()
+		if connected {
+			a.appendLog("INFO", "Control WebSocket 已连接")
+		} else {
+			a.appendLog("WARN", "Control WebSocket 已断开，正在重连")
+		}
+		a.emit()
+	}
+	options.OnLatency = func(delay time.Duration) {
+		milliseconds := int(delay.Round(time.Millisecond) / time.Millisecond)
+		if milliseconds < 1 {
+			milliseconds = 1
+		}
+		a.mu.Lock()
+		a.state.Session.LatencyMS = milliseconds
+		a.mu.Unlock()
+		a.emit()
+	}
+	options.OnNodeList = func(payload protocol.NodeListPayload) {
+		a.mu.Lock()
+		a.state.Sites = append([]protocol.SiteSummary{}, payload.Sites...)
+		a.mu.Unlock()
+		a.emit()
+	}
+	options.OnSession = a.onSession
+	options.OnEngineerReady = func(engine *sessionruntime.EngineerRuntime) {
+		a.mu.Lock()
+		a.engine = engine
+		a.mu.Unlock()
+		a.emit()
+	}
+	go func() {
+		if err := nodeagent.Run(ctx, options); err != nil && !errors.Is(err, context.Canceled) {
+			a.appendLog("ERROR", localization.ErrorMessage(err.Error()))
+			a.mu.Lock()
+			a.state.ServerConnected = false
+			a.state.ControlConnected = false
+			a.mu.Unlock()
+			a.emit()
+		}
+	}()
+}
+
+func (a *EngineerApp) Shutdown(context.Context) {
+	a.mu.Lock()
+	if a.cancel != nil {
+		a.cancel()
+	}
+	a.mu.Unlock()
+}
+
+func (a *EngineerApp) GetState() EngineerState {
+	a.mu.RLock()
+	state := a.state
+	// Wails serialises nil slices as JSON null. The frontend contract requires
+	// arrays even when they are empty, otherwise the first Vue render fails.
+	state.Sites = append([]protocol.SiteSummary{}, a.state.Sites...)
+	state.SiteCIDRs = make(map[string][]string, len(a.state.SiteCIDRs))
+	for siteID, cidrs := range a.state.SiteCIDRs {
+		state.SiteCIDRs[siteID] = append([]string(nil), cidrs...)
+	}
+	state.Logs = append([]EngineerLog{}, a.state.Logs...)
+	state.Session.CIDRs = append([]string{}, a.state.Session.CIDRs...)
+	engine := a.engine
+	a.mu.RUnlock()
+	if engine != nil {
+		snapshot := engine.Snapshot()
+		if snapshot.ID != 0 {
+			state.Session.ID = strconv.FormatUint(snapshot.ID, 10)
+			state.Session.Status = string(snapshot.Status)
+			state.Session.UploadBytes = snapshot.Counters.UploadBytes
+			state.Session.DownloadBytes = snapshot.Counters.DownloadBytes
+			state.Session.UploadPackets = snapshot.Counters.UploadPackets
+			state.Session.DownloadPackets = snapshot.Counters.DownloadPackets
+		}
+	}
+	return state
+}
+
+// SaveSiteCIDRs persists one Site's non-secret Remote CIDR profile beside the
+// Engineer executable. An empty list clears only that Site's profile.
+func (a *EngineerApp) SaveSiteCIDRs(siteNodeID string, cidrs []string) error {
+	a.mu.RLock()
+	engine := a.engine
+	sites := append([]protocol.SiteSummary(nil), a.state.Sites...)
+	profiles := a.profiles
+	a.mu.RUnlock()
+	if profiles == nil {
+		return errors.New("现场网段配置存储尚未就绪")
+	}
+	siteName := ""
+	for _, site := range sites {
+		if site.NodeID == siteNodeID {
+			siteName = site.Name
+			break
+		}
+	}
+	if siteName == "" {
+		return errors.New("所选 Site 不存在")
+	}
+	if len(cidrs) > 0 {
+		if engine == nil {
+			return errors.New("Engineer 网络运行时尚未就绪")
+		}
+		if err := engine.PreflightCIDRs(cidrs); err != nil {
+			return err
+		}
+	}
+	if err := profiles.Save(siteNodeID, siteName, cidrs); err != nil {
+		return err
+	}
+	a.mu.Lock()
+	if len(cidrs) == 0 {
+		delete(a.state.SiteCIDRs, siteNodeID)
+	} else {
+		a.state.SiteCIDRs[siteNodeID] = append([]string(nil), cidrs...)
+	}
+	a.mu.Unlock()
+	a.appendLog("INFO", fmt.Sprintf("已保存 %s 的远程网段配置（%d 个）", siteName, len(cidrs)))
+	a.emit()
+	return nil
+}
+
+func (a *EngineerApp) CreateSession(siteNodeID string, cidrs []string) (string, error) {
+	a.mu.RLock()
+	engine, ctx := a.engine, a.ctx
+	sites := append([]protocol.SiteSummary(nil), a.state.Sites...)
+	a.mu.RUnlock()
+	if engine == nil || ctx == nil {
+		return "", errors.New("Engineer 网络运行时尚未就绪")
+	}
+	if len(cidrs) == 0 {
+		return "", errors.New("至少输入一个 Remote CIDR")
+	}
+	siteName := ""
+	for _, site := range sites {
+		if site.NodeID == siteNodeID {
+			if !site.Online {
+				return "", errors.New("所选 Site 当前离线")
+			}
+			if !site.RemoteSubnetCapability {
+				return "", errors.New("所选 Site 不支持 Remote Subnet")
+			}
+			siteName = site.Name
+			break
+		}
+	}
+	if siteName == "" {
+		return "", errors.New("所选 Site 不存在")
+	}
+	if err := a.SaveSiteCIDRs(siteNodeID, cidrs); err != nil {
+		return "", err
+	}
+	a.mu.Lock()
+	previousSession := a.state.Session
+	now := time.Now().UTC()
+	a.state.Session = EngineerSessionState{
+		SiteName: siteName, CIDRs: append([]string(nil), cidrs...), Status: "IDLE",
+		LatencyMS: previousSession.LatencyMS, StartedAt: &now,
+	}
+	a.mu.Unlock()
+	requestID, err := engine.CreateSession(ctx, siteNodeID, cidrs)
+	if err != nil {
+		a.mu.Lock()
+		a.state.Session = previousSession
+		a.mu.Unlock()
+		a.appendLog("ERROR", localization.ErrorMessage(err.Error()))
+		a.emit()
+		return "", err
+	}
+	a.appendLog("INFO", fmt.Sprintf("正在连接 %s：%v", siteName, cidrs))
+	a.emit()
+	return requestID, nil
+}
+
+func (a *EngineerApp) DisconnectSession() error {
+	a.mu.RLock()
+	engine, ctx := a.engine, a.ctx
+	a.mu.RUnlock()
+	if engine == nil || ctx == nil {
+		return errors.New("Engineer 网络运行时尚未就绪")
+	}
+	return engine.Disconnect(ctx, "ENGINEER_OPERATOR")
+}
+
+func (a *EngineerApp) onSession(status model.SessionStatus, sessionID uint64, reason string) {
+	a.mu.Lock()
+	a.state.Session.Status = string(status)
+	if sessionID != 0 {
+		a.state.Session.ID = strconv.FormatUint(sessionID, 10)
+	}
+	a.state.Session.Reason = reason
+	if status == model.SessionClosed || status == model.SessionFailed {
+		a.state.Session.StartedAt = nil
+	}
+	a.mu.Unlock()
+	message := fmt.Sprintf("会话 %d → %s", sessionID, localization.SessionStatus(string(status)))
+	if reason != "" {
+		message += "；原因：" + localization.Reason(reason)
+	}
+	a.appendLog("INFO", message)
+	a.emit()
+}
+
+func (a *EngineerApp) appendLog(level, message string) {
+	a.mu.Lock()
+	a.state.Logs = append(a.state.Logs, EngineerLog{Time: time.Now().UTC(), Level: level, Message: message})
+	if len(a.state.Logs) > 200 {
+		a.state.Logs = append([]EngineerLog(nil), a.state.Logs[len(a.state.Logs)-200:]...)
+	}
+	a.mu.Unlock()
+}
+
+func (a *EngineerApp) emit() {
+	a.mu.RLock()
+	ctx := a.ctx
+	a.mu.RUnlock()
+	if ctx != nil {
+		runtime.EventsEmit(ctx, "remlink:state")
+	}
+}