459 lines
13 KiB
Go
459 lines
13 KiB
Go
package remote
|
|
|
|
import (
|
|
"crypto/subtle"
|
|
"embed"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
//go:embed web/*
|
|
var webAssets embed.FS
|
|
|
|
type ServerOptions struct {
|
|
Addr string
|
|
DataDir string
|
|
AgentToken string
|
|
OperatorToken string
|
|
EnrollToken string
|
|
EnrollWindow time.Duration
|
|
}
|
|
|
|
type Server struct {
|
|
opts ServerOptions
|
|
hub *Hub
|
|
tokens *tokenStore
|
|
upgrader websocket.Upgrader
|
|
enrollUntil time.Time
|
|
|
|
sessionsMu sync.RWMutex
|
|
sessions map[string]*agentConn
|
|
}
|
|
|
|
type agentConn struct {
|
|
conn *websocket.Conn
|
|
writeMu sync.Mutex
|
|
machineID string
|
|
machineName string
|
|
instanceID string
|
|
instanceName string
|
|
remoteAddr string
|
|
}
|
|
|
|
func NewServer(opts ServerOptions) (*Server, error) {
|
|
opts.Addr = strings.TrimSpace(opts.Addr)
|
|
if opts.Addr == "" {
|
|
opts.Addr = ":18080"
|
|
}
|
|
opts.AgentToken = strings.TrimSpace(opts.AgentToken)
|
|
opts.OperatorToken = strings.TrimSpace(opts.OperatorToken)
|
|
opts.EnrollToken = strings.TrimSpace(opts.EnrollToken)
|
|
if opts.OperatorToken == "" {
|
|
return nil, errors.New("OperatorToken 不能为空")
|
|
}
|
|
if opts.EnrollWindow <= 0 {
|
|
opts.EnrollWindow = 10 * time.Minute
|
|
}
|
|
hub, err := NewHub(opts.DataDir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tokens, err := newTokenStore(opts.DataDir)
|
|
if err != nil {
|
|
_ = hub.Close()
|
|
return nil, err
|
|
}
|
|
return &Server{
|
|
opts: opts,
|
|
hub: hub,
|
|
tokens: tokens,
|
|
enrollUntil: time.Now().Add(opts.EnrollWindow),
|
|
sessions: make(map[string]*agentConn),
|
|
upgrader: websocket.Upgrader{
|
|
HandshakeTimeout: 8 * time.Second,
|
|
CheckOrigin: func(r *http.Request) bool {
|
|
origin := strings.TrimSpace(r.Header.Get("Origin"))
|
|
return origin == "" || sameOrigin(origin, r.Host)
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (s *Server) Close() error {
|
|
s.sessionsMu.Lock()
|
|
for _, session := range s.sessions {
|
|
_ = session.conn.Close()
|
|
}
|
|
s.sessions = make(map[string]*agentConn)
|
|
s.sessionsMu.Unlock()
|
|
return s.hub.Close()
|
|
}
|
|
|
|
func (s *Server) Handler() http.Handler {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/api/health", s.handleHealth)
|
|
mux.HandleFunc("/api/dashboard", s.handleDashboard)
|
|
mux.HandleFunc("/api/events", s.handleEvents)
|
|
mux.HandleFunc("/api/export", s.handleExport)
|
|
mux.HandleFunc("/api/command", s.handleCommand)
|
|
mux.HandleFunc("/api/enroll", s.handleEnroll)
|
|
mux.HandleFunc("/ws/agent", s.handleAgent)
|
|
|
|
assets, _ := fs.Sub(webAssets, "web")
|
|
mux.Handle("/", http.FileServer(http.FS(assets)))
|
|
return mux
|
|
}
|
|
|
|
func (s *Server) handleExport(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorize(w, r, s.opts.OperatorToken) {
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
format := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("format")))
|
|
if format == "" {
|
|
format = "csv"
|
|
}
|
|
if format != "csv" && format != "json" {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "format 仅支持 csv 或 json"})
|
|
return
|
|
}
|
|
filter := EventExportFilter{
|
|
MachineID: strings.TrimSpace(r.URL.Query().Get("machineId")),
|
|
InstanceID: strings.TrimSpace(r.URL.Query().Get("instanceId")),
|
|
RunID: strings.TrimSpace(r.URL.Query().Get("runId")),
|
|
Query: strings.TrimSpace(r.URL.Query().Get("q")),
|
|
}
|
|
if raw := strings.TrimSpace(r.URL.Query().Get("from")); raw != "" {
|
|
value, err := time.Parse(time.RFC3339, raw)
|
|
if err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "from 时间格式应为 RFC3339"})
|
|
return
|
|
}
|
|
filter.From = value
|
|
}
|
|
if raw := strings.TrimSpace(r.URL.Query().Get("to")); raw != "" {
|
|
value, err := time.Parse(time.RFC3339, raw)
|
|
if err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "to 时间格式应为 RFC3339"})
|
|
return
|
|
}
|
|
filter.To = value
|
|
}
|
|
extension := format
|
|
if format == "json" {
|
|
extension = "json"
|
|
}
|
|
w.Header().Set("Content-Type", exportContentType(format))
|
|
w.Header().Set("Content-Disposition", fmt.Sprintf(
|
|
`attachment; filename="douyu-logs-%s.%s"`,
|
|
time.Now().Format("20060102-150405"),
|
|
extension,
|
|
))
|
|
if _, err := s.hub.ExportEvents(w, format, filter); err != nil {
|
|
// Headers may already be committed. The client receives a truncated file
|
|
// rather than blocking the control plane.
|
|
return
|
|
}
|
|
}
|
|
|
|
func (s *Server) handleEnroll(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
if s.opts.EnrollToken != "" {
|
|
provided := strings.TrimSpace(r.Header.Get("X-Enroll-Token"))
|
|
if subtle.ConstantTimeCompare([]byte(provided), []byte(s.opts.EnrollToken)) != 1 {
|
|
writeJSON(w, http.StatusUnauthorized, map[string]any{"error": "注册令牌无效"})
|
|
return
|
|
}
|
|
} else if time.Now().After(s.enrollUntil) {
|
|
writeJSON(w, http.StatusForbidden, map[string]any{"error": "实例自动注册窗口已关闭"})
|
|
return
|
|
}
|
|
var request struct {
|
|
MachineID string `json:"machineId"`
|
|
MachineName string `json:"machineName"`
|
|
InstanceID string `json:"instanceId"`
|
|
InstanceName string `json:"instanceName"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 64<<10)).Decode(&request); err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "请求格式错误"})
|
|
return
|
|
}
|
|
request.MachineID = strings.TrimSpace(request.MachineID)
|
|
request.InstanceID = strings.TrimSpace(request.InstanceID)
|
|
if request.MachineID == "" || request.InstanceID == "" {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "缺少机器或实例标识"})
|
|
return
|
|
}
|
|
token, err := s.tokens.Issue(request.MachineID, request.MachineName, request.InstanceID, request.InstanceName)
|
|
if err != nil {
|
|
writeJSON(w, http.StatusInternalServerError, map[string]any{"error": "生成实例令牌失败"})
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{"token": token})
|
|
}
|
|
|
|
func (s *Server) ListenAndServe() error {
|
|
server := &http.Server{
|
|
Addr: s.opts.Addr,
|
|
Handler: s.Handler(),
|
|
ReadHeaderTimeout: 10 * time.Second,
|
|
IdleTimeout: 90 * time.Second,
|
|
}
|
|
return server.ListenAndServe()
|
|
}
|
|
|
|
func (s *Server) handleHealth(w http.ResponseWriter, _ *http.Request) {
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"success": true,
|
|
"serverTime": time.Now(),
|
|
})
|
|
}
|
|
|
|
func (s *Server) handleDashboard(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorize(w, r, s.opts.OperatorToken) {
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, s.hub.Dashboard())
|
|
}
|
|
|
|
func (s *Server) handleEvents(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorize(w, r, s.opts.OperatorToken) {
|
|
return
|
|
}
|
|
if r.Method != http.MethodGet {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
since, _ := strconv.ParseUint(r.URL.Query().Get("since"), 10, 64)
|
|
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"events": s.hub.EventsSinceFiltered(
|
|
since,
|
|
limit,
|
|
strings.TrimSpace(r.URL.Query().Get("machineId")),
|
|
strings.TrimSpace(r.URL.Query().Get("instanceId")),
|
|
strings.TrimSpace(r.URL.Query().Get("runId")),
|
|
),
|
|
})
|
|
}
|
|
|
|
func (s *Server) handleCommand(w http.ResponseWriter, r *http.Request) {
|
|
if !s.authorize(w, r, s.opts.OperatorToken) {
|
|
return
|
|
}
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
var request struct {
|
|
MachineID string `json:"machineId"`
|
|
InstanceID string `json:"instanceId"`
|
|
Type string `json:"type"`
|
|
}
|
|
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 64<<10)).Decode(&request); err != nil {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "请求格式错误"})
|
|
return
|
|
}
|
|
request.Type = strings.TrimSpace(request.Type)
|
|
if !allowedCommand(request.Type) {
|
|
writeJSON(w, http.StatusBadRequest, map[string]any{"error": "不支持的命令"})
|
|
return
|
|
}
|
|
id, err := randomID()
|
|
if err != nil {
|
|
writeJSON(w, http.StatusInternalServerError, map[string]any{"error": err.Error()})
|
|
return
|
|
}
|
|
key := instanceKey(request.MachineID, request.InstanceID)
|
|
s.sessionsMu.RLock()
|
|
session := s.sessions[key]
|
|
s.sessionsMu.RUnlock()
|
|
if session == nil {
|
|
writeJSON(w, http.StatusConflict, map[string]any{"error": "实例当前离线"})
|
|
return
|
|
}
|
|
now := time.Now()
|
|
command := Command{
|
|
ID: id,
|
|
Type: request.Type,
|
|
CreatedAt: now,
|
|
ExpiresAt: now.Add(30 * time.Second),
|
|
}
|
|
s.hub.AddCommand(CommandAudit{
|
|
ID: id,
|
|
MachineID: request.MachineID,
|
|
MachineName: session.machineName,
|
|
InstanceID: request.InstanceID,
|
|
InstanceName: session.instanceName,
|
|
Type: request.Type,
|
|
State: "queued",
|
|
CreatedAt: now,
|
|
})
|
|
if err := session.write(Envelope{Type: MessageCommand, Command: &command}); err != nil {
|
|
writeJSON(w, http.StatusBadGateway, map[string]any{"error": "命令发送失败: " + err.Error()})
|
|
return
|
|
}
|
|
s.hub.MarkCommandDelivered(id)
|
|
writeJSON(w, http.StatusOK, map[string]any{"success": true, "commandId": id})
|
|
}
|
|
|
|
func (s *Server) handleAgent(w http.ResponseWriter, r *http.Request) {
|
|
token := requestToken(r)
|
|
legacy := s.opts.AgentToken != "" && subtle.ConstantTimeCompare([]byte(token), []byte(s.opts.AgentToken)) == 1
|
|
if !legacy && !s.tokens.Valid(token) {
|
|
writeJSON(w, http.StatusUnauthorized, map[string]any{"error": "未授权"})
|
|
return
|
|
}
|
|
conn, err := s.upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
session := &agentConn{conn: conn, remoteAddr: r.RemoteAddr}
|
|
defer conn.Close()
|
|
|
|
var key string
|
|
defer func() {
|
|
if key != "" {
|
|
s.sessionsMu.Lock()
|
|
if s.sessions[key] == session {
|
|
delete(s.sessions, key)
|
|
s.hub.MarkOffline(session.machineID, session.instanceID)
|
|
}
|
|
s.sessionsMu.Unlock()
|
|
}
|
|
}()
|
|
|
|
conn.SetReadLimit(2 << 20)
|
|
for {
|
|
var envelope Envelope
|
|
if err := conn.ReadJSON(&envelope); err != nil {
|
|
return
|
|
}
|
|
switch envelope.Type {
|
|
case MessageHello, MessageHeartbeat, MessageSnapshot:
|
|
snapshot := envelope.Hello
|
|
if envelope.Type != MessageHello {
|
|
snapshot = envelope.Snapshot
|
|
}
|
|
if snapshot == nil || snapshot.MachineID == "" || snapshot.InstanceID == "" {
|
|
continue
|
|
}
|
|
if !legacy && !s.tokens.Matches(token, snapshot.MachineID, snapshot.InstanceID) {
|
|
_ = conn.WriteControl(
|
|
websocket.CloseMessage,
|
|
websocket.FormatCloseMessage(websocket.ClosePolicyViolation, "instance token identity mismatch"),
|
|
time.Now().Add(2*time.Second),
|
|
)
|
|
return
|
|
}
|
|
session.machineID = snapshot.MachineID
|
|
session.machineName = snapshot.MachineName
|
|
session.instanceID = snapshot.InstanceID
|
|
session.instanceName = snapshot.InstanceName
|
|
newKey := instanceKey(snapshot.MachineID, snapshot.InstanceID)
|
|
s.sessionsMu.Lock()
|
|
if key != "" && key != newKey {
|
|
delete(s.sessions, key)
|
|
}
|
|
s.sessions[newKey] = session
|
|
key = newKey
|
|
s.sessionsMu.Unlock()
|
|
s.hub.ApplySnapshot(*snapshot, r.RemoteAddr)
|
|
case MessageEvents:
|
|
s.hub.AppendEvents(envelope.Events)
|
|
case MessageCommandResult:
|
|
if envelope.Result != nil {
|
|
s.hub.ApplyCommandResult(*envelope.Result)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *agentConn) write(envelope Envelope) error {
|
|
c.writeMu.Lock()
|
|
defer c.writeMu.Unlock()
|
|
_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
|
|
return c.conn.WriteJSON(envelope)
|
|
}
|
|
|
|
func (s *Server) authorize(w http.ResponseWriter, r *http.Request, expected string) bool {
|
|
provided := requestToken(r)
|
|
if subtle.ConstantTimeCompare([]byte(provided), []byte(expected)) == 1 {
|
|
return true
|
|
}
|
|
writeJSON(w, http.StatusUnauthorized, map[string]any{"error": "未授权"})
|
|
return false
|
|
}
|
|
|
|
func requestToken(r *http.Request) string {
|
|
provided := strings.TrimSpace(r.Header.Get("X-Control-Token"))
|
|
if provided == "" {
|
|
auth := strings.TrimSpace(r.Header.Get("Authorization"))
|
|
if strings.HasPrefix(strings.ToLower(auth), "bearer ") {
|
|
provided = strings.TrimSpace(auth[7:])
|
|
}
|
|
}
|
|
if provided == "" {
|
|
provided = strings.TrimSpace(r.URL.Query().Get("token"))
|
|
}
|
|
return provided
|
|
}
|
|
|
|
func allowedCommand(command string) bool {
|
|
switch command {
|
|
case "ping", "status", "stop", "cancel_schedule":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, status int, value any) {
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(status)
|
|
_ = json.NewEncoder(w).Encode(value)
|
|
}
|
|
|
|
func exportContentType(format string) string {
|
|
if format == "json" {
|
|
return "application/json; charset=utf-8"
|
|
}
|
|
return "text/csv; charset=utf-8"
|
|
}
|
|
|
|
func sameOrigin(origin, host string) bool {
|
|
origin = strings.TrimSpace(origin)
|
|
if origin == "" {
|
|
return true
|
|
}
|
|
origin = strings.TrimPrefix(strings.TrimPrefix(origin, "https://"), "http://")
|
|
return strings.EqualFold(origin, host)
|
|
}
|
|
|
|
func RandomToken() (string, error) {
|
|
id, err := randomID()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("%s-%s", id[:16], id[16:]), nil
|
|
}
|