Files
dygou_go/internal/remote/credentials.go
T

160 lines
4.1 KiB
Go

package remote
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"path/filepath"
"strings"
"time"
)
type agentCredential struct {
ServerURL string `json:"serverUrl"`
MachineID string `json:"machineId"`
InstanceID string `json:"instanceId"`
Token string `json:"token"`
EnrolledAt string `json:"enrolledAt,omitempty"`
}
func loadAgentCredential(dataDir, serverURL, machineID, instanceID string) (string, error) {
path := agentCredentialPath(dataDir)
data, err := os.ReadFile(path)
if errors.Is(err, os.ErrNotExist) {
return "", nil
}
if err != nil {
return "", err
}
var credential agentCredential
if err := json.Unmarshal(data, &credential); err != nil {
return "", err
}
if credential.ServerURL != serverURL || credential.MachineID != machineID || credential.InstanceID != instanceID {
return "", nil
}
return strings.TrimSpace(credential.Token), nil
}
func saveAgentCredential(dataDir, serverURL, machineID, instanceID, token string) error {
path := agentCredentialPath(dataDir)
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
credential := agentCredential{
ServerURL: serverURL,
MachineID: machineID,
InstanceID: instanceID,
Token: token,
EnrolledAt: time.Now().Format(time.RFC3339),
}
data, err := json.MarshalIndent(credential, "", " ")
if err != nil {
return err
}
temp, err := os.CreateTemp(filepath.Dir(path), ".agent-credential-*.tmp")
if err != nil {
return err
}
tempPath := temp.Name()
defer func() { _ = os.Remove(tempPath) }()
if err := temp.Chmod(0o600); err != nil {
_ = temp.Close()
return err
}
if _, err := temp.Write(data); err != nil {
_ = temp.Close()
return err
}
if err := temp.Close(); err != nil {
return err
}
return os.Rename(tempPath, path)
}
func clearAgentCredential(dataDir string) {
_ = os.Remove(agentCredentialPath(dataDir))
}
func agentCredentialPath(dataDir string) string {
return filepath.Join(MachineDataDir(dataDir), "remote", "instances", safeInstanceFileName(dataDir)+".json")
}
func safeInstanceFileName(dataDir string) string {
base := filepath.Base(filepath.Clean(dataDir))
if base == "" || base == "." {
return "default"
}
return base
}
func enrollAgent(serverURL string, options AgentOptions) (string, error) {
endpoint, err := enrollHTTPURL(serverURL)
if err != nil {
return "", err
}
payload := map[string]string{
"machineId": options.MachineID,
"machineName": options.MachineName,
"instanceId": options.InstanceID,
"instanceName": options.Instance,
}
data, err := json.Marshal(payload)
if err != nil {
return "", err
}
request, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewReader(data))
if err != nil {
return "", err
}
request.Header.Set("Content-Type", "application/json")
if token := strings.TrimSpace(options.EnrollmentToken); token != "" {
request.Header.Set("X-Enroll-Token", token)
}
client := &http.Client{Timeout: 10 * time.Second}
response, err := client.Do(request)
if err != nil {
return "", fmt.Errorf("自动注册实例失败: %w", err)
}
defer response.Body.Close()
body, _ := io.ReadAll(io.LimitReader(response.Body, 64<<10))
if response.StatusCode != http.StatusOK {
return "", fmt.Errorf("自动注册实例失败: HTTP %d %s", response.StatusCode, strings.TrimSpace(string(body)))
}
var result struct {
Token string `json:"token"`
}
if err := json.Unmarshal(body, &result); err != nil {
return "", fmt.Errorf("解析实例注册结果失败: %w", err)
}
if strings.TrimSpace(result.Token) == "" {
return "", errors.New("实例注册成功但未返回令牌")
}
return strings.TrimSpace(result.Token), nil
}
func enrollHTTPURL(raw string) (string, error) {
u, err := url.Parse(strings.TrimSpace(raw))
if err != nil {
return "", err
}
switch strings.ToLower(u.Scheme) {
case "http", "https":
case "ws":
u.Scheme = "http"
case "wss":
u.Scheme = "https"
default:
return "", errors.New("远端地址协议无效")
}
if strings.TrimSpace(u.Path) == "" || u.Path == "/" {
u.Path = "/api/enroll"
}
return u.String(), nil
}