160 lines
4.1 KiB
Go
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
|
|
}
|