Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package hostagent
import (
"compress/gzip"
"context"
"encoding/json"
"encoding/pem"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"runtime"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/hostmetrics"
agentshost "github.com/rcourtman/pulse-go-rewrite/pkg/agents/host"
"github.com/rs/zerolog"
gohost "github.com/shirou/gopsutil/v4/host"
)
// realFSCollector returns a mockCollector wired to real filesystem operations.
func realFSCollector() *mockCollector {
return &mockCollector{
readFileFn: func(name string) ([]byte, error) { return os.ReadFile(name) },
writeFileFn: func(name string, data []byte, perm os.FileMode) error { return os.WriteFile(name, data, perm) },
mkdirAllFn: func(path string, perm os.FileMode) error { return os.MkdirAll(path, perm) },
chmodFn: func(name string, mode os.FileMode) error { return os.Chmod(name, mode) },
}
}
func TestEnroll_Success(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != enrollEndpoint {
t.Fatalf("unexpected path: %s", r.URL.Path)
}
if r.Method != http.MethodPost {
t.Fatalf("unexpected method: %s", r.Method)
}
var req enrollPayload
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
t.Fatalf("decode request: %v", err)
}
if req.Hostname != "test-host" {
t.Errorf("expected hostname test-host, got %s", req.Hostname)
}
if !req.CommandsEnabled {
t.Error("expected commandsEnabled to be true")
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(enrollResponse{
AgentID: "host-test-host",
RuntimeToken: "runtime-tok-123",
RuntimeTokenID: "tok-id-456",
ReportInterval: "30s",
})
}))
defer server.Close()
stateDir := t.TempDir()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
EnableCommands: true,
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
osName: "linux",
architecture: "amd64",
agentVersion: "1.0.0",
trimmedPulseURL: server.URL,
stateDir: stateDir,
collector: realFSCollector(),
}
err := agent.runEnrollmentLoop(context.Background())
if err != nil {
t.Fatalf("enrollment failed: %v", err)
}
// Verify token was updated.
if agent.cfg.APIToken != "runtime-tok-123" {
t.Errorf("expected token runtime-tok-123, got %s", agent.cfg.APIToken)
}
if agent.agentID != "host-test-host" || agent.cfg.AgentID != "host-test-host" {
t.Fatalf("running agent identity was not updated after enrollment: agent=%q config=%q", agent.agentID, agent.cfg.AgentID)
}
// Verify runtime token was persisted.
tokenPath := filepath.Join(stateDir, runtimeTokenFile)
data, err := os.ReadFile(tokenPath)
if err != nil {
t.Fatalf("read runtime token file: %v", err)
}
if string(data) != "runtime-tok-123" {
t.Errorf("expected persisted token runtime-tok-123, got %s", string(data))
}
// Verify agent-id was persisted.
agentIDPath := filepath.Join(stateDir, "agent-id")
data, err = os.ReadFile(agentIDPath)
if err != nil {
t.Fatalf("read agent-id file: %v", err)
}
if string(data) != "host-test-host" {
t.Errorf("expected agent-id host-test-host, got %s", string(data))
}
}
func TestEnroll_PrefersAgentIDFromResponse(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(enrollResponse{
AgentID: "agent-canonical",
RuntimeToken: "runtime-tok-123",
})
}))
defer server.Close()
stateDir := t.TempDir()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
osName: "linux",
architecture: "amd64",
agentVersion: "1.0.0",
trimmedPulseURL: server.URL,
stateDir: stateDir,
collector: realFSCollector(),
}
if err := agent.runEnrollmentLoop(context.Background()); err != nil {
t.Fatalf("enrollment failed: %v", err)
}
agentIDPath := filepath.Join(stateDir, "agent-id")
data, err := os.ReadFile(agentIDPath)
if err != nil {
t.Fatalf("read agent-id file: %v", err)
}
if got := string(data); got != "agent-canonical" {
t.Fatalf("expected persisted agent-id agent-canonical, got %s", got)
}
}
func TestEnroll_AlreadyEnrolled(t *testing.T) {
stateDir := t.TempDir()
// Write an existing runtime token.
tokenPath := filepath.Join(stateDir, runtimeTokenFile)
if err := os.WriteFile(tokenPath, []byte("existing-runtime-tok"), 0600); err != nil {
t.Fatal(err)
}
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
Enroll: true,
},
logger: logger,
stateDir: stateDir,
collector: &mockCollector{
readFileFn: func(name string) ([]byte, error) {
return os.ReadFile(name)
},
},
}
err := agent.runEnrollmentLoop(context.Background())
if err != nil {
t.Fatalf("enrollment failed: %v", err)
}
// Should use the existing runtime token.
if agent.cfg.APIToken != "existing-runtime-tok" {
t.Errorf("expected token existing-runtime-tok, got %s", agent.cfg.APIToken)
}
}
func TestEnroll_403_SkipsEnrollment(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Forbidden", http.StatusForbidden)
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "manual-install-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
err := agent.runEnrollmentLoop(context.Background())
if err != nil {
t.Fatalf("enrollment should skip on 403, got error: %v", err)
}
// Token should remain unchanged.
if agent.cfg.APIToken != "manual-install-tok" {
t.Errorf("expected token unchanged, got %s", agent.cfg.APIToken)
}
}
func TestEnroll_RetryThenSuccess(t *testing.T) {
// Speed up retries for this test.
origInitial := enrollInitialDelay
origMax := enrollMaxDelay
enrollInitialDelay = 10 * time.Millisecond
enrollMaxDelay = 50 * time.Millisecond
defer func() {
enrollInitialDelay = origInitial
enrollMaxDelay = origMax
}()
var attempts atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
n := attempts.Add(1)
if n < 3 {
http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(enrollResponse{
AgentID: "host-retry",
RuntimeToken: "runtime-after-retry",
})
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "retry-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err := agent.runEnrollmentLoop(ctx)
if err != nil {
t.Fatalf("enrollment should succeed after retries, got: %v", err)
}
if agent.cfg.APIToken != "runtime-after-retry" {
t.Errorf("expected token runtime-after-retry, got %s", agent.cfg.APIToken)
}
if got := attempts.Load(); got < 3 {
t.Errorf("expected at least 3 attempts, got %d", got)
}
}
func TestEnroll_ContextCancelled(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "cancel-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
ctx, cancel := context.WithCancel(context.Background())
// Cancel after a short delay.
go func() {
time.Sleep(100 * time.Millisecond)
cancel()
}()
err := agent.runEnrollmentLoop(ctx)
if err == nil {
t.Fatal("expected error from cancelled context")
}
}
func TestEnrollStatusError(t *testing.T) {
err := &enrollStatusError{StatusCode: 401, Body: "Unauthorized"}
expected := "enrollment returned HTTP 401: Unauthorized"
if err.Error() != expected {
t.Errorf("expected %q, got %q", expected, err.Error())
}
}
func TestEnroll_401_PermanentFailure(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "expired-bootstrap-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
err := agent.runEnrollmentLoop(context.Background())
if err == nil {
t.Fatal("expected error for 401 permanent failure")
}
if !strings.Contains(err.Error(), "401") {
t.Errorf("expected 401 in error, got: %v", err)
}
}
func TestEnroll_409_PermanentFailure(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Conflict", http.StatusConflict)
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "consumed-bootstrap-tok",
Enroll: true,
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
err := agent.runEnrollmentLoop(context.Background())
if err == nil {
t.Fatal("expected error for 409 permanent failure")
}
if !strings.Contains(err.Error(), "409") {
t.Errorf("expected 409 in error, got: %v", err)
}
}
func TestEnroll_MissingRuntimeToken(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
// Return a response missing runtimeToken.
fmt.Fprint(w, `{"agentId":"agent-1"}`)
}))
defer server.Close()
logger := zerolog.New(zerolog.NewTestWriter(t))
agent := &Agent{
cfg: Config{
APIToken: "bootstrap-tok",
},
logger: logger,
httpClient: server.Client(),
hostname: "test-host",
trimmedPulseURL: server.URL,
stateDir: t.TempDir(),
collector: &mockCollector{},
}
_, err := agent.enroll(context.Background())
if err == nil {
t.Fatal("expected error for missing runtimeToken")
}
}
func enrollmentTestCollector(hostname string) *mockCollector {
collector := realFSCollector()
collector.goos = "darwin" // keep OS identity on HostInfo, not the test machine's files
collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
return &gohost.InfoStat{Hostname: hostname, Platform: "debian", KernelArch: "x86_64"}, nil
}
return collector
}
// A process that enrolls before building its modules must get back the
// runtime token and canonical agent ID, persisted where a restart finds them,
// and must present the same host identity New would report under.
func TestEnrollExchangesBootstrapTokenBeforeModulesStart(t *testing.T) {
var gotPayload enrollPayload
var gotAuth string
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != enrollEndpoint || r.Method != http.MethodPost {
t.Fatalf("unexpected request %s %s", r.Method, r.URL.Path)
}
gotAuth = r.Header.Get("Authorization")
if err := json.NewDecoder(r.Body).Decode(&gotPayload); err != nil {
t.Fatalf("decode request: %v", err)
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(enrollResponse{AgentID: "canonical-delly2", RuntimeToken: "runtime-tok"})
}))
defer server.Close()
stateDir := t.TempDir()
logger := zerolog.New(zerolog.NewTestWriter(t))
result, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "bootstrap-tok",
StateDir: stateDir,
HostnameOverride: "delly2",
AgentVersion: "6.5.0",
EnableCommands: true,
CommandAuthorityProfile: CommandAuthorityCommandCapable,
Logger: &logger,
Collector: enrollmentTestCollector("ignored-by-override"),
})
if err != nil {
t.Fatalf("Enroll() error = %v", err)
}
if result.APIToken != "runtime-tok" || result.AgentID != "canonical-delly2" {
t.Fatalf("Enroll() = %+v, want runtime token and canonical agent ID", result)
}
if gotAuth != "Bearer bootstrap-tok" {
t.Fatalf("enrollment authenticated with %q, want the bootstrap token", gotAuth)
}
want := enrollPayload{Hostname: "delly2", OS: "debian", Arch: "x86_64", AgentVersion: "6.5.0", CommandsEnabled: true}
if gotPayload != want {
t.Fatalf("enrollment payload = %+v, want %+v", gotPayload, want)
}
for file, want := range map[string]string{runtimeTokenFile: "runtime-tok", "agent-id": "canonical-delly2"} {
data, err := os.ReadFile(filepath.Join(stateDir, file))
if err != nil || string(data) != want {
t.Fatalf("%s = %q (err %v), want %q", file, data, err, want)
}
}
}
// A monitoring-only install must not ask the server for command authority
// during enrollment, matching the ceiling New applies.
func TestEnrollHonoursMonitoringOnlyCommandCeiling(t *testing.T) {
var gotPayload enrollPayload
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewDecoder(r.Body).Decode(&gotPayload)
json.NewEncoder(w).Encode(enrollResponse{RuntimeToken: "runtime-tok"})
}))
defer server.Close()
if _, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "bootstrap-tok",
StateDir: t.TempDir(),
EnableCommands: true,
CommandAuthorityProfile: CommandAuthorityMonitoringOnly,
Collector: enrollmentTestCollector("pve-3"),
}); err != nil {
t.Fatalf("Enroll() error = %v", err)
}
if gotPayload.CommandsEnabled {
t.Fatal("monitoring-only enrollment requested command authority")
}
if gotPayload.Hostname != "pve-3" {
t.Fatalf("enrollment hostname = %q, want the discovered hostname", gotPayload.Hostname)
}
}
// A restart with a persisted runtime token must not contact the server again.
func TestEnrollReusesPersistedRuntimeToken(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
t.Fatalf("persisted runtime token must not trigger an enrollment request")
}))
defer server.Close()
stateDir := t.TempDir()
if err := os.WriteFile(filepath.Join(stateDir, runtimeTokenFile), []byte("persisted-runtime-tok\n"), 0600); err != nil {
t.Fatal(err)
}
result, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "bootstrap-tok",
StateDir: stateDir,
Collector: enrollmentTestCollector("pve-3"),
})
if err != nil {
t.Fatalf("Enroll() error = %v", err)
}
if result.APIToken != "persisted-runtime-tok" || result.AgentID != "" {
t.Fatalf("Enroll() = %+v, want the persisted token and no new agent ID", result)
}
}
func TestEnrollKeepsTokenTheServerSaysIsNotABootstrapToken(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Forbidden", http.StatusForbidden)
}))
defer server.Close()
result, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "manual-install-tok",
StateDir: t.TempDir(),
Collector: enrollmentTestCollector("pve-3"),
})
if err != nil {
t.Fatalf("Enroll() error = %v", err)
}
if result.APIToken != "manual-install-tok" || result.AgentID != "" {
t.Fatalf("Enroll() = %+v, want the original token unchanged", result)
}
}
func TestEnrollReturnsPermanentRejection(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "token already consumed", http.StatusConflict)
}))
defer server.Close()
_, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "spent-bootstrap-tok",
StateDir: t.TempDir(),
Collector: enrollmentTestCollector("pve-3"),
})
if err == nil || !strings.Contains(err.Error(), "409") {
t.Fatalf("Enroll() error = %v, want the permanent 409 rejection", err)
}
}
func TestEnrollRequiresToken(t *testing.T) {
if _, err := Enroll(context.Background(), EnrollmentConfig{PulseURL: "http://127.0.0.1:7655"}); err == nil {
t.Fatal("Enroll() without a token succeeded")
}
}
// A restart that already holds a runtime token must not depend on host
// discovery: Docker- or Kubernetes-only agents never needed it to start.
func TestEnrollReusesPersistedRuntimeTokenWithoutHostDiscovery(t *testing.T) {
stateDir := t.TempDir()
if err := os.WriteFile(filepath.Join(stateDir, runtimeTokenFile), []byte("persisted-runtime-tok"), 0600); err != nil {
t.Fatal(err)
}
collector := realFSCollector()
collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
return nil, errors.New("host information unavailable")
}
result, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: "http://127.0.0.1:1",
APIToken: "bootstrap-tok",
StateDir: stateDir,
Collector: collector,
})
if err != nil {
t.Fatalf("Enroll() error = %v, want the persisted token without host discovery", err)
}
if result.APIToken != "persisted-runtime-tok" {
t.Fatalf("Enroll() token = %q, want the persisted runtime token", result.APIToken)
}
}
// The server binds the runtime token to the hostname presented at
// enrollment, so Enroll must present exactly the identity New reports under,
// including Linux distribution detection and the architecture fallback.
func TestEnrollPresentsTheIdentityNewReports(t *testing.T) {
collector := &mockCollector{
hostInfoFn: func(context.Context) (*gohost.InfoStat, error) {
return &gohost.InfoStat{
Hostname: " pve-host ",
HostID: "hid",
Platform: "debian",
PlatformFamily: "debian",
PlatformVersion: "13.4",
}, nil
},
statFn: func(name string) (os.FileInfo, error) {
if name == "/etc/pve" {
return nil, nil
}
return nil, os.ErrNotExist
},
lookPathFn: func(file string) (string, error) {
if file == "pveversion" {
return "/usr/bin/pveversion", nil
}
return "", os.ErrNotExist
},
commandCombinedOutputFn: func(context.Context, string, ...string) (string, error) {
return "pve-manager/9.1.9/ee7bad0a3d1546c9 (running kernel: 7.0.0-3-pve)", nil
},
}
agent, err := New(Config{APIToken: "token", HostnameOverride: " ", LogLevel: zerolog.InfoLevel, Collector: collector})
if err != nil {
t.Fatalf("New() error = %v", err)
}
var gotPayload enrollPayload
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewDecoder(r.Body).Decode(&gotPayload)
json.NewEncoder(w).Encode(enrollResponse{RuntimeToken: "runtime-tok"})
}))
defer server.Close()
if _, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL,
APIToken: "bootstrap-tok",
StateDir: t.TempDir(),
HostnameOverride: " ",
Collector: collector,
}); err != nil {
t.Fatalf("Enroll() error = %v", err)
}
if gotPayload.Hostname != agent.hostname || gotPayload.OS != agent.osName || gotPayload.Arch != agent.architecture {
t.Fatalf("enrollment identity = %q/%q/%q, New reports %q/%q/%q",
gotPayload.Hostname, gotPayload.OS, gotPayload.Arch, agent.hostname, agent.osName, agent.architecture)
}
if agent.hostname != "pve-host" || agent.osName != proxmoxPVEOSName || agent.architecture != runtime.GOARCH {
t.Fatalf("New identity = %q/%q/%q, want the trimmed hostname, Proxmox VE, and the runtime architecture", agent.hostname, agent.osName, agent.architecture)
}
}
// #2854: inject gopsutil's raspi-config heuristic, but read Debian's actual
// metadata through a real synthetic /etc -> /usr/lib symlink. Neither the
// reporter's Pi nor gopsutil's absolute-file heuristic is executed here.
func TestEnrollAndReportUseDebianOSReleaseIdentity(t *testing.T) {
root := t.TempDir()
for _, dir := range []string{"etc", "usr/lib"} {
if err := os.MkdirAll(filepath.Join(root, dir), 0700); err != nil {
t.Fatal(err)
}
}
const release = "PRETTY_NAME=\"Debian GNU/Linux 13 (trixie)\"\nNAME=\"Debian GNU/Linux\"\nVERSION_ID=\"13\"\nDEBIAN_VERSION_FULL=13.7\nID=debian\n"
if err := os.WriteFile(filepath.Join(root, "usr/lib/os-release"), []byte(release), 0600); err != nil {
t.Fatal(err)
}
if err := os.Symlink("../usr/lib/os-release", filepath.Join(root, "etc/os-release")); err != nil {
t.Fatal(err)
}
collector := realFSCollector()
collector.goos = "linux"
collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
return &gohost.InfoStat{
Hostname: "pi-host", HostID: "synthetic-machine-id",
Platform: "raspbian", PlatformFamily: "debian", PlatformVersion: "13.7",
KernelArch: "aarch64",
}, nil
}
collector.readFileFn = func(path string) ([]byte, error) {
if path == "/etc/os-release" {
return os.ReadFile(filepath.Join(root, "etc/os-release"))
}
if strings.HasPrefix(path, root+string(os.PathSeparator)) {
return os.ReadFile(path)
}
return nil, os.ErrNotExist
}
collector.metricsFn = func(context.Context, []string) (hostmetrics.Snapshot, error) {
return hostmetrics.Snapshot{CPUCount: 4, CPUUsagePercent: 7.5}, nil
}
var enrollment enrollPayload
var received agentshost.Report
var receiptMu sync.Mutex
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
receiptMu.Lock()
defer receiptMu.Unlock()
switch r.URL.Path {
case enrollEndpoint:
if r.Header.Get("Authorization") != "Bearer synthetic-bootstrap" {
t.Error("enrollment credential changed")
}
if err := json.NewDecoder(r.Body).Decode(&enrollment); err != nil {
t.Error(err)
w.WriteHeader(http.StatusBadRequest)
return
}
json.NewEncoder(w).Encode(enrollResponse{AgentID: "canonical-agent", RuntimeToken: "synthetic-runtime"})
case agentReportEndpoint:
if r.Header.Get("Authorization") != "Bearer synthetic-runtime" {
t.Error("report credential changed")
}
reader, err := gzip.NewReader(r.Body)
if err != nil {
t.Error(err)
w.WriteHeader(http.StatusBadRequest)
return
}
defer reader.Close()
if err := json.NewDecoder(reader).Decode(&received); err != nil {
t.Error(err)
w.WriteHeader(http.StatusBadRequest)
return
}
json.NewEncoder(w).Encode(map[string]bool{"success": true})
default:
t.Errorf("unexpected request: %s", r.URL.Path)
w.WriteHeader(http.StatusNotFound)
}
}))
defer server.Close()
caPath := filepath.Join(root, "test-ca.pem")
if err := os.WriteFile(caPath, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: server.Certificate().Raw}), 0600); err != nil {
t.Fatal(err)
}
stateDir := filepath.Join(root, "state")
result, err := Enroll(context.Background(), EnrollmentConfig{
PulseURL: server.URL, APIToken: "synthetic-bootstrap", StateDir: stateDir,
HostnameOverride: " pi-label ", Collector: collector, CACertPath: caPath,
})
if err != nil {
t.Fatal(err)
}
agent, err := New(Config{
PulseURL: server.URL, APIToken: result.APIToken, AgentID: result.AgentID,
StateDir: stateDir, HostnameOverride: " pi-label ", Collector: collector,
CACertPath: caPath, LogLevel: zerolog.Disabled, DisableCeph: true,
})
if err != nil {
t.Fatal(err)
}
report, err := agent.buildReport(context.Background())
if err != nil {
t.Fatal(err)
}
if err := agent.sendReport(context.Background(), report); err != nil {
t.Fatal(err)
}
receiptMu.Lock()
defer receiptMu.Unlock()
if received.Host.OSName != "debian" || received.Host.OSVersion != "13.7" {
t.Fatalf("received OS = %q %q, want debian 13.7", received.Host.OSName, received.Host.OSVersion)
}
if received.Host.Hostname != "pi-label" || received.Host.MachineID != "synthetic-machine-id" || received.Host.Architecture != "aarch64" || received.Agent.ID != "canonical-agent" {
t.Fatalf("host/agent identity changed: %+v / %q", received.Host, received.Agent.ID)
}
if enrollment.Hostname != received.Host.Hostname || enrollment.OS != received.Host.OSName || enrollment.Arch != received.Host.Architecture || enrollment.CommandsEnabled || received.Agent.CommandsEnabled {
t.Fatalf("enrollment/report identity or commands-off control changed: %+v / %+v", enrollment, received.Agent)
}
if received.Host.CPUCount != 4 || received.Metrics.CPUUsagePercent != 7.5 {
t.Fatal("OS identity correction changed collected metrics")
}
if saved, err := os.ReadFile(filepath.Join(stateDir, runtimeTokenFile)); err != nil || string(saved) != "synthetic-runtime" {
t.Fatalf("saved synthetic credential changed: %q / %v", saved, err)
}
t.Logf("trusted synthetic enrollment/report: %s %s, hostname=%s, machine=%s, agent=%s, arch=%s, commands=false, CPU=7.5",
received.Host.OSName, received.Host.OSVersion, received.Host.Hostname, received.Host.MachineID, received.Agent.ID, received.Host.Architecture)
}