Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package event
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strings"
"sync"
"sync/atomic"
"testing"
"testing/synctest"
"time"
"github.com/getarcaneapp/arcane/types/v2/event"
"github.com/libtnb/sqlite"
"github.com/moby/moby/api/types/events"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.getarcane.app/kit/pkg"
"go.getarcane.app/streams/bus"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/event/children/correlation"
"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
)
func setupEventServiceTestDB(t *testing.T) *database.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&Event{}))
return &database.DB{DB: db}
}
func TestCreateEventRequestJSONOmitempty(t *testing.T) {
t.Run("includes optional fields when set", func(t *testing.T) {
payload, err := json.Marshal(CreateEventRequest{
Type: EventTypeContainerStart,
Title: "Container started",
Description: "Container 'web' has been started",
ResourceType: new("container"),
ResourceID: new("container-1"),
ResourceName: new("web"),
UserID: new("user-1"),
Username: new("arcane"),
})
require.NoError(t, err)
var decoded map[string]any
require.NoError(t, json.Unmarshal(payload, &decoded))
require.Equal(t, "container", decoded["resourceType"])
require.Equal(t, "container-1", decoded["resourceId"])
require.Equal(t, "web", decoded["resourceName"])
require.Equal(t, "user-1", decoded["userId"])
require.Equal(t, "arcane", decoded["username"])
})
t.Run("omits optional fields when nil", func(t *testing.T) {
payload, err := json.Marshal(CreateEventRequest{
Type: EventTypeUserLogin,
Title: "User logged in",
})
require.NoError(t, err)
var decoded map[string]any
require.NoError(t, json.Unmarshal(payload, &decoded))
_, hasResourceType := decoded["resourceType"]
_, hasResourceID := decoded["resourceId"]
_, hasResourceName := decoded["resourceName"]
_, hasUserID := decoded["userId"]
_, hasUsername := decoded["username"]
require.False(t, hasResourceType)
require.False(t, hasResourceID)
require.False(t, hasResourceName)
require.False(t, hasUserID)
require.False(t, hasUsername)
})
}
func TestEventService_LogEventsPersistOptionalPointers(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
metadata := database.JSON{"source": "test"}
err := svc.LogContainerEvent(ctx, EventTypeContainerStart, "container-1", "web", "user-1", "arcane", "0", metadata)
require.NoError(t, err)
var containerEvent Event
err = db.WithContext(ctx).Where("type = ?", EventTypeContainerStart).First(&containerEvent).Error
require.NoError(t, err)
require.NotNil(t, containerEvent.ResourceType)
require.Equal(t, "container", *containerEvent.ResourceType)
require.NotNil(t, containerEvent.ResourceID)
require.Equal(t, "container-1", *containerEvent.ResourceID)
require.NotNil(t, containerEvent.ResourceName)
require.Equal(t, "web", *containerEvent.ResourceName)
require.NotNil(t, containerEvent.UserID)
require.Equal(t, "user-1", *containerEvent.UserID)
require.NotNil(t, containerEvent.Username)
require.Equal(t, "arcane", *containerEvent.Username)
require.NotNil(t, containerEvent.EnvironmentID)
require.Equal(t, "0", *containerEvent.EnvironmentID)
require.Equal(t, "test", containerEvent.Metadata["source"])
err = svc.LogUserEvent(ctx, EventTypeUserLogin, "user-2", "arcane-user", nil)
require.NoError(t, err)
var userEvent Event
err = db.WithContext(ctx).Where("type = ?", EventTypeUserLogin).First(&userEvent).Error
require.NoError(t, err)
require.Nil(t, userEvent.ResourceType)
require.Nil(t, userEvent.ResourceID)
require.Nil(t, userEvent.ResourceName)
require.NotNil(t, userEvent.UserID)
require.Equal(t, "user-2", *userEvent.UserID)
require.NotNil(t, userEvent.Username)
require.Equal(t, "arcane-user", *userEvent.Username)
}
func TestCloneEventMetadata(t *testing.T) {
src := database.JSON{"a": "b"}
cloned := cloneEventMetadata(src)
require.Equal(t, "b", cloned["a"])
cloned["a"] = "changed"
require.Equal(t, "b", src["a"], "clone should not mutate source metadata")
nilClone := cloneEventMetadata(nil)
require.NotNil(t, nilClone)
require.Empty(t, nilClone)
nested := database.JSON{
"outer": map[string]any{
"slice": []any{
map[string]any{"k": "v"},
},
},
}
nestedClone := cloneEventMetadata(nested)
require.NotNil(t, nestedClone["outer"])
outer := nested["outer"].(map[string]any)
outerClone := nestedClone["outer"].(database.JSON)
sliceOriginal := outer["slice"].([]any)
sliceClone := outerClone["slice"].([]any)
sliceClone[0].(database.JSON)["k"] = "changed"
require.Equal(t, "v", sliceOriginal[0].(map[string]any)["k"], "nested map inside slice should be deep-cloned")
}
func TestEventService_LogErrorEvent_DoesNotMutateInputMetadata(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
metadata := database.JSON{"phase": "pull"}
svc.LogErrorEvent(
ctx,
EventTypeImageScan,
"image",
"img-1",
"nginx:latest",
"user-1",
"arcane",
"0",
errors.New("pull failed"),
metadata,
)
_, mutated := metadata["error"]
require.False(t, mutated, "input metadata should not be mutated by LogErrorEvent")
var saved Event
err := db.WithContext(ctx).Where("type = ?", EventTypeImageScan).First(&saved).Error
require.NoError(t, err)
require.Equal(t, EventSeverityError, saved.Severity)
require.Equal(t, "pull", saved.Metadata["phase"])
require.Equal(t, "pull failed", saved.Metadata["error"])
}
func TestEventService_CreateEvent_ForwardsToManagerAPIInAgentMode(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
requests := make(chan CreateEventRequest, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !assert.Equal(t, http.MethodPost, r.Method) {
return
}
if !assert.Equal(t, "/api/events", r.URL.Path) {
return
}
if !assert.Equal(t, "test-agent-token", r.Header.Get(middleware.HeaderAgentToken)) {
return
}
defer func() { _ = r.Body.Close() }()
var payload CreateEventRequest
if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&payload)) {
return
}
select {
case requests <- payload:
default:
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"success":true}`))
}))
defer server.Close()
cfg := &config.Config{
AgentMode: true,
AgentToken: "test-agent-token",
ManagerApiUrl: server.URL,
}
svc := NewEventService(db, cfg, server.Client())
_, err := svc.CreateEvent(ctx, CreateEventRequest{
Type: EventTypeContainerStart,
Severity: EventSeverityInfo,
Title: "Container started: web",
Description: "Container 'web' has been started",
EnvironmentID: new("0"),
Metadata: database.JSON{"source": "test"},
})
require.NoError(t, err)
select {
case payload := <-requests:
require.Equal(t, EventTypeContainerStart, payload.Type)
require.Equal(t, EventSeverityInfo, payload.Severity)
require.Equal(t, "Container started: web", payload.Title)
require.NotNil(t, payload.EnvironmentID)
require.Equal(t, "0", *payload.EnvironmentID)
require.Equal(t, "test", payload.Metadata["source"])
case <-time.After(2 * time.Second):
require.FailNow(t, "timed out waiting for manager event sync request")
}
}
func TestEventService_CreateEvent_NormalizesActor(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
t.Run("falls back to system when actor is missing", func(t *testing.T) {
evt, err := svc.CreateEvent(ctx, CreateEventRequest{
Type: EventTypeSystemAutoUpdate,
Severity: EventSeverityInfo,
Title: "System task",
})
require.NoError(t, err)
require.NotNil(t, evt.UserID)
require.NotNil(t, evt.Username)
require.Equal(t, "system", *evt.UserID)
require.Equal(t, "System", *evt.Username)
})
t.Run("copies user id to username when username is missing", func(t *testing.T) {
evt, err := svc.CreateEvent(ctx, CreateEventRequest{
Type: EventTypeProjectDeploy,
Severity: EventSeverityInfo,
Title: "Deploy",
UserID: new("u-123"),
})
require.NoError(t, err)
require.NotNil(t, evt.UserID)
require.NotNil(t, evt.Username)
require.Equal(t, "u-123", *evt.UserID)
require.Equal(t, "u-123", *evt.Username)
})
t.Run("copies username to user id when user id is missing", func(t *testing.T) {
evt, err := svc.CreateEvent(ctx, CreateEventRequest{
Type: EventTypeProjectDeploy,
Severity: EventSeverityInfo,
Title: "Deploy",
Username: new("kmendell"),
})
require.NoError(t, err)
require.NotNil(t, evt.UserID)
require.NotNil(t, evt.Username)
require.Equal(t, "kmendell", *evt.UserID)
require.Equal(t, "kmendell", *evt.Username)
})
}
func TestEventService_GetEventSeverityCounts(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
seed := []EventSeverity{
EventSeverityInfo,
EventSeverityInfo,
EventSeveritySuccess,
EventSeverityError,
}
for i, severity := range seed {
_, err := svc.CreateEvent(ctx, CreateEventRequest{
Type: EventTypeContainerStart,
Severity: severity,
Title: "event",
})
require.NoError(t, err, "seed event %d", i)
}
counts, err := svc.GetEventSeverityCounts(ctx)
require.NoError(t, err)
require.Equal(t, event.SeverityCounts{Total: 4, Info: 2, Success: 1, Warning: 0, Error: 1}, counts)
}
func TestEventService_ListEventsPaginated_TypeCategoryFilter(t *testing.T) {
ctx := t.Context()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
for _, eventType := range []EventType{
EventTypeContainerStart,
EventTypeContainerStop,
EventTypeImagePull,
} {
_, err := svc.CreateEvent(ctx, CreateEventRequest{Type: eventType, Title: "event"})
require.NoError(t, err)
}
listWithTypeFilter := func(value string) []string {
events, _, err := svc.ListEventsPaginated(ctx, pagination.QueryParams{
Limit: 10,
Filters: map[string]string{"type": value},
})
require.NoError(t, err)
types := make([]string, 0, len(events))
for _, e := range events {
types = append(types, e.Type)
}
return types
}
require.ElementsMatch(t, []string{"container.start", "container.stop"}, listWithTypeFilter("container"))
require.ElementsMatch(t, []string{"image.pull"}, listWithTypeFilter("image.pull"))
require.ElementsMatch(t, []string{"container.start", "container.stop", "image.pull"}, listWithTypeFilter("container,image.pull"))
}
func TestIngestAgentEventAuthenticatedEnvironment(t *testing.T) {
for _, supplied := range []string{"0", "unrelated-environment", ""} {
t.Run("payload environment "+supplied, func(t *testing.T) {
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
req, ok := mapDaemonEvent(events.Message{
Type: events.ContainerEventType,
Action: events.ActionStart,
Actor: events.Actor{
ID: "container-id",
Attributes: map[string]string{
"name": "web",
"com.docker.compose.project": "demo",
},
},
})
require.True(t, ok)
req.EnvironmentID = &supplied
recorded, err := svc.IngestAgentEvent(t.Context(), " remote-environment ", req)
require.NoError(t, err)
require.Equal(t, "remote-environment", *recorded.EnvironmentID)
require.Equal(t, "System", *recorded.Username)
require.Equal(t, req.Metadata, recorded.Metadata)
require.False(t, svc.ShouldSuppressDaemonEvent("container", "container-id", "web", "demo"))
var persisted Event
require.NoError(t, db.First(&persisted).Error)
require.Equal(t, "remote-environment", *persisted.EnvironmentID)
require.Equal(t, database.JSON{"source": "docker", "action": "start", "scope": "", "name": "web", "composeProject": "demo"}, persisted.Metadata)
// Attributed Arcane records must not seed expectations for the manager's daemon either.
req.Metadata = nil
req.UserID = new("operator-id")
req.Username = new("operator")
recorded, err = svc.IngestAgentEvent(t.Context(), "remote-environment", req)
require.NoError(t, err)
require.Equal(t, "operator", *recorded.Username)
require.False(t, svc.ShouldSuppressDaemonEvent("container", "container-id", "web", "demo"))
})
}
}
func TestIngestAgentEventRejectsLocalEnvironment(t *testing.T) {
for _, environmentID := range []string{"", " ", "0", " 0 "} {
t.Run("environment "+environmentID, func(t *testing.T) {
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
recorded, err := svc.IngestAgentEvent(t.Context(), environmentID, CreateEventRequest{Type: EventTypeContainerStart, Title: "start", EnvironmentID: new("remote-environment")})
require.Error(t, err)
require.Nil(t, recorded)
requireDaemonCount(t, db, 0)
})
}
}
func TestDaemonEventForwardingPreservesMetadata(t *testing.T) {
requests := make(chan CreateEventRequest, 4)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var req CreateEventRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
t.Errorf("decode forwarded event: %v", err)
w.WriteHeader(http.StatusBadRequest)
return
}
requests <- req
w.WriteHeader(http.StatusAccepted)
}))
defer server.Close()
db := setupEventServiceTestDB(t)
svc := NewEventService(db, &config.Config{AgentMode: true, AgentToken: "agent-token", ManagerApiUrl: server.URL}, server.Client())
message := events.Message{
Type: events.ContainerEventType,
Action: events.ActionDie,
TimeNano: 123,
Actor: events.Actor{
ID: "container-id",
Attributes: map[string]string{
"name": "web",
"exitCode": "137",
"signal": "9",
},
},
}
req, ok := mapDaemonEvent(message)
require.True(t, ok)
svc.RecordDockerEvent(t.Context(), message)
svc.RecordDockerEvent(t.Context(), message)
require.NoError(t, svc.Stop(t.Context()))
select {
case payload := <-requests:
require.Equal(t, req.Metadata, payload.Metadata)
require.Equal(t, EventSeverityWarning, payload.Severity)
require.Equal(t, EventTypeContainerDie, payload.Type)
require.Equal(t, "System", *payload.Username)
require.Equal(t, "0", *payload.EnvironmentID)
require.Equal(t, "container-id", *payload.ResourceID)
case <-time.After(2 * time.Second):
t.Fatal("timed out waiting for daemon event forwarding")
}
require.Never(t, func() bool { return len(requests) != 0 }, 50*time.Millisecond, time.Millisecond)
requireDaemonCount(t, db, 1)
}
func TestEventStreamPublishesCommittedMutations(t *testing.T) {
db := setupEventServiceTestDB(t)
service := NewEventService(db, nil, nil)
changes := 0
var persistedCounts []int64
unsubscribe := service.changes.Subscribe(func(struct{}) {
changes++
var count int64
require.NoError(t, db.Model(&Event{}).Count(&count).Error)
persistedCounts = append(persistedCounts, count)
})
defer unsubscribe()
created, err := service.CreateEvent(t.Context(), CreateEventRequest{Type: EventTypeImagePull, Title: "Pulled"})
require.NoError(t, err)
require.Equal(t, 1, changes)
_, err = service.IngestAgentEvent(t.Context(), "remote", CreateEventRequest{Type: EventTypeImagePull, Title: "Remote pull"})
require.NoError(t, err)
require.Equal(t, 2, changes)
require.NoError(t, service.DeleteOldEvents(t.Context(), time.Hour))
require.Equal(t, 2, changes)
require.Error(t, service.DeleteEvent(t.Context(), "missing"))
require.Equal(t, 2, changes)
require.NoError(t, service.DeleteEvent(t.Context(), created.ID))
require.Equal(t, 3, changes)
require.NoError(t, service.DeleteOldEvents(t.Context(), -time.Hour))
require.Equal(t, 4, changes)
require.Equal(t, []int64{1, 2, 1, 0}, persistedCounts)
require.NoError(t, db.Migrator().DropTable(&Event{}))
_, err = service.CreateEvent(t.Context(), CreateEventRequest{Title: "Cannot persist"})
require.Error(t, err)
require.Error(t, service.DeleteOldEvents(t.Context(), time.Hour))
require.Error(t, service.DeleteEvent(t.Context(), created.ID))
require.Equal(t, 4, changes)
}
func TestEventStreamProducerCoalescesAndCancels(t *testing.T) {
synctest.Test(t, func(t *testing.T) {
service := NewEventService(nil, nil, nil)
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
output := make(chan event.StreamEvent)
stopped := make(chan struct{})
go func() {
defer close(stopped)
service.RunStreamProducer(ctx, output)
}()
synctest.Wait()
// Initial send is blocked, but subscriptions must already be ready.
for range 100 {
service.changes.Publish(struct{}{})
}
initial := <-output
require.Equal(t, "changed", initial.Type)
require.False(t, initial.Timestamp.IsZero())
require.Equal(t, "changed", (<-output).Type)
synctest.Wait()
select {
case <-output:
t.Fatal("burst should coalesce to one pending invalidation")
default:
}
// A stalled client must not hold up publishers or prevent shutdown.
service.changes.Publish(struct{}{})
synctest.Wait()
cancel()
<-stopped
service.changes.Publish(struct{}{})
})
}
func TestEventStreamProducerBroadcasts(t *testing.T) {
synctest.Test(t, func(t *testing.T) {
service := NewEventService(nil, nil, nil)
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
first := make(chan event.StreamEvent, 1)
second := make(chan event.StreamEvent, 1)
go service.RunStreamProducer(ctx, first)
go service.RunStreamProducer(ctx, second)
synctest.Wait()
<-first
<-second
service.changes.Publish(struct{}{})
synctest.Wait()
require.Equal(t, "changed", (<-first).Type)
require.Equal(t, "changed", (<-second).Type)
})
}
func TestMapDaemonEvent(t *testing.T) {
t.Parallel()
cases := []struct {
name string
kind events.Type
action events.Action
want EventType
}{
{"container create", events.ContainerEventType, events.ActionCreate, EventTypeContainerCreate},
{"container start", events.ContainerEventType, events.ActionStart, EventTypeContainerStart},
{"container stop", events.ContainerEventType, events.ActionStop, EventTypeContainerStop},
{"container restart", events.ContainerEventType, events.ActionRestart, EventTypeContainerRestart},
{"container die", events.ContainerEventType, events.ActionDie, EventTypeContainerDie},
{"container oom", events.ContainerEventType, events.ActionOOM, EventTypeContainerOOM},
{"container kill", events.ContainerEventType, events.ActionKill, EventTypeContainerKill},
{"container destroy", events.ContainerEventType, events.ActionDestroy, EventTypeContainerDelete},
{"container pause", events.ContainerEventType, events.ActionPause, EventTypeContainerPause},
{"container unpause", events.ContainerEventType, events.ActionUnPause, EventTypeContainerUnpause},
{"container rename", events.ContainerEventType, events.ActionRename, EventTypeContainerRename},
{"container update", events.ContainerEventType, events.ActionUpdate, EventTypeContainerUpdate},
{"container unhealthy", events.ContainerEventType, events.ActionHealthStatusUnhealthy, EventTypeContainerUnhealthy},
{"image pull", events.ImageEventType, events.ActionPull, EventTypeImagePull},
{"image delete", events.ImageEventType, events.ActionDelete, EventTypeImageDelete},
{"image tag", events.ImageEventType, events.ActionTag, EventTypeImageTag},
{"image untag", events.ImageEventType, events.ActionUnTag, EventTypeImageUntag},
{"image load", events.ImageEventType, events.ActionLoad, EventTypeImageLoad},
{"image import", events.ImageEventType, events.ActionImport, EventTypeImageImport},
{"image prune", events.ImageEventType, events.ActionPrune, EventTypeImagePrune},
{"volume create", events.VolumeEventType, events.ActionCreate, EventTypeVolumeCreate},
{"volume destroy", events.VolumeEventType, events.ActionDestroy, EventTypeVolumeDelete},
{"volume prune", events.VolumeEventType, events.ActionPrune, EventTypeVolumePrune},
{"network create", events.NetworkEventType, events.ActionCreate, EventTypeNetworkCreate},
{"network destroy", events.NetworkEventType, events.ActionDestroy, EventTypeNetworkDelete},
{"network prune", events.NetworkEventType, events.ActionPrune, EventTypeNetworkPrune},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
req, ok := mapDaemonEvent(events.Message{
Type: tc.kind,
Action: tc.action,
Scope: "local",
Actor: events.Actor{
ID: "resource-id",
Attributes: map[string]string{
"name": "web",
"image": "alpine",
"exitCode": "0",
"signal": "15",
"com.docker.compose.project": "demo",
"com.docker.compose.service": "web",
"secret": "never-copy",
},
},
})
require.True(t, ok)
require.Equal(t, tc.want, req.Type)
require.Equal(t, "web", *req.ResourceName)
require.Equal(t, "0", *req.EnvironmentID)
require.Nil(t, req.UserID)
require.Nil(t, req.Username)
require.Equal(
t,
database.JSON{
"source": "docker",
"action": string(tc.action),
"scope": "local",
"name": "web",
"image": "alpine",
"exitCode": "0",
"signal": "15",
"composeProject": "demo",
"composeService": "web",
},
req.Metadata,
)
severity := kit.Ternary(tc.action == events.ActionOOM, EventSeverityError, EventSeverityInfo)
if tc.action == events.ActionHealthStatusUnhealthy {
severity = EventSeverityWarning
}
require.Equal(t, severity, req.Severity)
})
}
for _, exitCode := range []string{"1", "137", ""} {
t.Run("die exit "+exitCode, func(t *testing.T) {
req, ok := mapDaemonEvent(events.Message{
Type: events.ContainerEventType,
Action: events.ActionDie,
Actor: events.Actor{
ID: "id",
Attributes: map[string]string{"exitCode": exitCode},
},
})
require.True(t, ok)
require.Equal(t, EventSeverityWarning, req.Severity)
require.Equal(t, "id", *req.ResourceName)
})
}
for _, kind := range []events.Type{events.ImageEventType, events.VolumeEventType, events.NetworkEventType} {
t.Run(string(kind)+" empty prune", func(t *testing.T) {
req, ok := mapDaemonEvent(events.Message{Type: kind, Action: events.ActionPrune})
require.True(t, ok)
require.Equal(t, "prune", *req.ResourceName)
})
}
for _, tc := range []struct {
name string
kind events.Type
action events.Action
id string
}{
{
"exec",
events.ContainerEventType,
"exec_create",
"id",
}, {
"attach",
events.ContainerEventType,
"attach",
"id",
}, {
"resize",
events.ContainerEventType,
"resize",
"id",
}, {
"healthy",
events.ContainerEventType,
"health_status: healthy",
"id",
}, {
"mount",
events.VolumeEventType,
"mount",
"id",
}, {
"connect",
events.NetworkEventType,
"connect",
"id",
}, {
"disconnect",
events.NetworkEventType,
"disconnect",
"id",
}, {
"unknown action",
events.ImageEventType,
"unknown-image-action",
"image-id",
}, {
"empty create",
events.ContainerEventType,
events.ActionCreate,
"",
},
} {
t.Run(tc.name, func(t *testing.T) {
_, ok := mapDaemonEvent(events.Message{Type: tc.kind, Action: tc.action, Actor: events.Actor{ID: tc.id}})
require.False(t, ok)
})
}
}
func TestDaemonEventsPersistEveryOccurrence(t *testing.T) {
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
die := events.Message{Type: events.ContainerEventType, Action: events.ActionDie, Actor: events.Actor{ID: "web", Attributes: map[string]string{"exitCode": "0"}}}
stop := die
stop.Action = events.ActionStop
for index, msg := range []events.Message{die, stop, die, stop} {
msg.TimeNano = int64(index + 1)
svc.RecordDockerEvent(t.Context(), msg)
}
require.NoError(t, svc.Stop(t.Context()))
requireDaemonCount(t, db, 4)
var rows []Event
require.NoError(t, db.Find(&rows).Error)
for _, row := range rows {
require.Equal(t, "System", *row.Username)
require.Equal(t, "0", *row.EnvironmentID)
require.Equal(t, "docker", row.Metadata["source"])
}
}
func TestDaemonSuppressionAndFailureAllowLaterObservations(t *testing.T) {
for _, failure := range []bool{false, true} {
name := kit.Ternary(failure, "persistence failure", "suppression")
t.Run(name, func(t *testing.T) {
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
now := time.Now()
svc.correlation = correlation.NewService(func() time.Time { return now })
msg := events.Message{Type: events.ContainerEventType, Action: events.ActionStart, TimeNano: 123, Actor: events.Actor{ID: "web"}}
if failure {
require.NoError(t, db.Callback().Create().Before("gorm:create").Register("daemon_failure", func(tx *gorm.DB) {
failureErr := errors.New("unavailable")
require.ErrorIs(t, tx.AddError(failureErr), failureErr)
}))
}
if !failure {
svc.MarkDockerExpectation("container", "web", "")
}
svc.RecordDockerEvent(t.Context(), msg)
require.NoError(t, svc.Stop(t.Context()))
requireDaemonCount(t, db, 0)
if failure {
require.NoError(t, db.Callback().Create().Remove("daemon_failure"))
}
now = now.Add(time.Minute)
svc.RecordDockerEvent(t.Context(), msg)
requireDaemonCount(t, db, 1)
})
}
}
func TestDockerEventSubscriptionsReadyAndStop(t *testing.T) {
for _, closeBus := range []bool{false, true} {
name := kit.Ternary(closeBus, "closed bus", "cancellation")
t.Run(name, func(t *testing.T) {
synctest.Test(t, func(t *testing.T) {
db := setupEventServiceTestDB(t)
sqlDB, err := db.DB.DB()
require.NoError(t, err)
defer func() { assert.NoError(t, sqlDB.Close()) }()
sqlDB.SetMaxOpenConns(1)
svc := NewEventService(db, nil, nil)
var recovered, published atomic.Int64
stopChanges := svc.changes.Subscribe(func(struct{}) { published.Add(1) })
defer stopChanges()
eventBus := bus.NewDockerEventBus(bus.WithDroppedEventCallback(func(message events.Message) {
recovered.Add(1)
svc.RecordDockerEvent(t.Context(), message)
}))
defer eventBus.Close()
run, cleanup := svc.SubscribeDockerEvents(eventBus)
defer cleanup()
// A stalled unrelated subscriber also invokes the global overflow callback.
_, stopStalled := eventBus.Subscribe(events.ImageEventType, bus.WithSubscriberBuffer(1))
defer stopStalled()
const occurrences = daemonEventChanBuffer + 64
publishBurst := func(offset int64) {
for occurrence := range occurrences {
for _, kind := range []events.Type{events.ContainerEventType, events.ImageEventType, events.VolumeEventType, events.NetworkEventType} {
action := kit.Ternary(kind == events.ImageEventType, events.ActionPull, events.ActionCreate)
eventBus.Publish(events.Message{Type: kind, Action: action, TimeNano: offset + int64(occurrence+1), Actor: events.Actor{ID: "resource"}})
}
}
}
publishBurst(0)
require.Positive(t, recovered.Load())
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
done := make(chan error, 1)
go func() { done <- run(ctx) }()
synctest.Wait()
time.Sleep(daemonEventFlushInterval)
synctest.Wait()
requireDaemonCount(t, db, 4*occurrences)
require.Equal(t, int64(4*occurrences), published.Load())
publishBurst(occurrences)
synctest.Wait()
time.Sleep(daemonEventFlushInterval)
synctest.Wait()
requireDaemonCount(t, db, 8*occurrences)
require.Equal(t, int64(8*occurrences), published.Load())
if closeBus {
eventBus.Close()
} else {
cancel()
}
synctest.Wait()
require.NoError(t, <-done)
require.NoError(t, svc.Stop(t.Context()))
cleanup()
cleanup()
})
})
}
}
func TestDaemonEventWriterBatchesAndFlushesOnStop(t *testing.T) {
synctest.Test(t, func(t *testing.T) {
db := setupEventServiceTestDB(t)
sqlDB, err := db.DB.DB()
require.NoError(t, err)
defer func() { assert.NoError(t, sqlDB.Close()) }()
sqlDB.SetMaxOpenConns(1)
svc := NewEventService(db, nil, nil)
defer func() { assert.NoError(t, svc.Stop(t.Context())) }()
var published atomic.Int64
stopChanges := svc.changes.Subscribe(func(struct{}) { published.Add(1) })
defer stopChanges()
record := func(timeNano int64) {
svc.RecordDockerEvent(t.Context(), events.Message{Type: events.ContainerEventType, Action: events.ActionStart, TimeNano: timeNano, Actor: events.Actor{ID: "web"}})
}
const occurrences = DaemonEventBatchSize*3 + 5
var wg sync.WaitGroup
for occurrence := range int64(occurrences) {
for range 2 {
wg.Go(func() { record(occurrence + 1) })
}
}
wg.Wait()
synctest.Wait()
time.Sleep(daemonEventFlushInterval)
synctest.Wait()
requireDaemonCount(t, db, occurrences)
require.Equal(t, int64(occurrences), published.Load())
// Fewer than a batch stays queued until the flush timer, which Stop preempts.
for occurrence := range int64(5) {
record(occurrences + occurrence + 1)
}
require.NoError(t, svc.Stop(t.Context()))
requireDaemonCount(t, db, occurrences+5)
record(occurrences + 6)
requireDaemonCount(t, db, occurrences+6)
require.Equal(t, int64(occurrences+6), published.Load())
})
}
func requireDaemonCount(t *testing.T, db *database.DB, want int64) {
t.Helper()
var count int64
require.NoError(t, db.Model(&Event{}).Count(&count).Error)
require.Equal(t, want, count)
}
func TestCreateEventCorrelationEligibility(t *testing.T) {
for _, tc := range []struct {
name string
environment *string
source string
eventType EventType
want bool
}{
{"local", new("0"), "", EventTypeContainerStart, true},
{"implicit local", nil, "", EventTypeContainerStart, true},
{"remote", new("remote"), "", EventTypeContainerStart, false},
{"daemon", new("0"), "docker", EventTypeContainerStart, false},
{"failure", new("0"), "", EventTypeContainerError, false},
{"container scan", new("0"), "", EventTypeContainerScan, false},
{"image scan", new("0"), "", EventTypeImageScan, false},
{"volume backup", new("0"), "", EventTypeVolumeBackupCreate, false},
} {
t.Run(tc.name, func(t *testing.T) {
db := setupEventServiceTestDB(t)
svc := NewEventService(db, nil, nil)
_, err := svc.CreateEvent(
t.Context(),
CreateEventRequest{
Type: tc.eventType,
Title: "action",
ResourceType: new(strings.SplitN(
string(tc.eventType),
".",
2,
)[0]),
ResourceID: new("id"),
EnvironmentID: tc.environment,
Metadata: database.JSON{"source": tc.source},
},
)
require.NoError(t, err)
require.Equal(t, tc.want, svc.ShouldSuppressDaemonEvent(strings.SplitN(string(tc.eventType), ".", 2)[0], "id", "", ""))
})
}
}