Skip to content

Modern Docker Management, Designed for Everyone

fix: track active updates in status maps and bound error-event logging path (#1817)

Kyle Mendell959e973522b7
diff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.go
index 23d54ae15..24c7bee0d 100644
--- a/backend/internal/services/event_service.go
+++ b/backend/internal/services/event_service.go
@@ -322,44 +322,66 @@ func (s *EventService) LogErrorEvent(ctx context.Context, eventType models.Event
return
}
- // Run error logging in background to prevent blocking the main flow
- // Detach context to ensure logging completes even if request is canceled
- bgCtx := context.WithoutCancel(ctx)
- go func() {
- // Set a timeout for the background logging
- logCtx, cancel := context.WithTimeout(bgCtx, 30*time.Second)
- defer cancel()
-
- if metadata == nil {
- metadata = models.JSON{}
- }
- metadata["error"] = err.Error()
+ // Detach cancellation but keep a bounded timeout to avoid unbounded goroutine fanout.
+ logCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
+ defer cancel()
- titleCaser := cases.Title(language.English)
- title := fmt.Sprintf("%s error", titleCaser.String(resourceType))
- if resourceName != "" {
- title = fmt.Sprintf("%s error: %s", titleCaser.String(resourceType), resourceName)
- }
+ eventMetadata := cloneEventMetadataInternal(metadata)
+ eventMetadata["error"] = err.Error()
+
+ titleCaser := cases.Title(language.English)
+ title := fmt.Sprintf("%s error", titleCaser.String(resourceType))
+ if resourceName != "" {
+ title = fmt.Sprintf("%s error: %s", titleCaser.String(resourceType), resourceName)
+ }
+
+ description := fmt.Sprintf("Failed to perform operation on %s: %s", resourceType, err.Error())
- description := fmt.Sprintf("Failed to perform operation on %s: %s", resourceType, err.Error())
-
- _, logErr := s.CreateEvent(logCtx, CreateEventRequest{
- Type: eventType,
- Severity: models.EventSeverityError,
- Title: title,
- Description: description,
- ResourceType: new(resourceType),
- ResourceID: new(resourceID),
- ResourceName: new(resourceName),
- UserID: new(userID),
- Username: new(username),
- EnvironmentID: new(environmentID),
- Metadata: metadata,
- })
- if logErr != nil {
- slog.ErrorContext(logCtx, "Failed to log error event", "error", logErr)
+ _, logErr := s.CreateEvent(logCtx, CreateEventRequest{
+ Type: eventType,
+ Severity: models.EventSeverityError,
+ Title: title,
+ Description: description,
+ ResourceType: new(resourceType),
+ ResourceID: new(resourceID),
+ ResourceName: new(resourceName),
+ UserID: new(userID),
+ Username: new(username),
+ EnvironmentID: new(environmentID),
+ Metadata: eventMetadata,
+ })
+ if logErr != nil {
+ slog.ErrorContext(logCtx, "Failed to log error event", "error", logErr)
+ }
+}
+
+func cloneEventMetadataInternal(metadata models.JSON) models.JSON {
+ if metadata == nil {
+ return models.JSON{}
+ }
+
+ cloned := make(models.JSON, len(metadata))
+ for k, v := range metadata {
+ cloned[k] = cloneEventMetadataValueInternal(v)
+ }
+ return cloned
+}
+
+func cloneEventMetadataValueInternal(value any) any {
+ switch typed := value.(type) {
+ case models.JSON:
+ return cloneEventMetadataInternal(typed)
+ case map[string]any:
+ return cloneEventMetadataInternal(models.JSON(typed))
+ case []any:
+ out := make([]any, len(typed))
+ for i := range typed {
+ out[i] = cloneEventMetadataValueInternal(typed[i])
}
- }()
+ return out
+ default:
+ return value
+ }
}
var eventDefinitions = map[models.EventType]struct {
diff --git a/backend/internal/services/event_service_test.go b/backend/internal/services/event_service_test.go
index d0c325619..127de6c0f 100644
--- a/backend/internal/services/event_service_test.go
+++ b/backend/internal/services/event_service_test.go
@@ -3,6 +3,7 @@ package services
import (
"context"
"encoding/json"
+ "errors"
"testing"
"github.com/getarcaneapp/arcane/backend/internal/database"
@@ -110,3 +111,64 @@ func TestEventService_LogEventsPersistOptionalPointers(t *testing.T) {
require.NotNil(t, userEvent.Username)
require.Equal(t, "arcane-user", *userEvent.Username)
}
+
+func TestCloneEventMetadataInternal(t *testing.T) {
+ src := models.JSON{"a": "b"}
+ cloned := cloneEventMetadataInternal(src)
+
+ require.Equal(t, "b", cloned["a"])
+ cloned["a"] = "changed"
+ require.Equal(t, "b", src["a"], "clone should not mutate source metadata")
+
+ nilClone := cloneEventMetadataInternal(nil)
+ require.NotNil(t, nilClone)
+ require.Empty(t, nilClone)
+
+ nested := models.JSON{
+ "outer": map[string]any{
+ "slice": []any{
+ map[string]any{"k": "v"},
+ },
+ },
+ }
+ nestedClone := cloneEventMetadataInternal(nested)
+ require.NotNil(t, nestedClone["outer"])
+
+ outer := nested["outer"].(map[string]any)
+ outerClone := nestedClone["outer"].(models.JSON)
+ sliceOriginal := outer["slice"].([]any)
+ sliceClone := outerClone["slice"].([]any)
+
+ sliceClone[0].(models.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 := context.Background()
+ db := setupEventServiceTestDB(t)
+ svc := NewEventService(db)
+
+ metadata := models.JSON{"phase": "pull"}
+ svc.LogErrorEvent(
+ ctx,
+ models.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 models.Event
+ err := db.WithContext(ctx).Where("type = ?", models.EventTypeImageScan).First(&saved).Error
+ require.NoError(t, err)
+ require.Equal(t, models.EventSeverityError, saved.Severity)
+ require.Equal(t, "pull", saved.Metadata["phase"])
+ require.Equal(t, "pull failed", saved.Metadata["error"])
+}
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 81ad11b29..70e456a07 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -763,6 +763,7 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
}
if len(externalCreds) > 0 {
+ enabledRegHosts := make(map[string]struct{})
for _, c := range externalCreds {
if !c.Enabled || c.Username == "" || c.Token == "" {
continue
@@ -774,6 +775,9 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
if _, exists := credMap[host]; !exists {
credMap[host] = batchCred{username: c.Username, token: c.Token}
}
+ if _, exists := enabledRegHosts[host]; exists {
+ continue
+ }
encToken, encErr := crypto.Encrypt(c.Token)
if encErr != nil {
slog.WarnContext(ctx, "Failed to encrypt external registry token", "registryURL", c.URL, "error", encErr.Error())
@@ -785,6 +789,7 @@ func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCre
Token: encToken,
Enabled: c.Enabled,
})
+ enabledRegHosts[host] = struct{}{}
}
slog.DebugContext(ctx, "Using external credentials for batch check", "credentialCount", len(credMap))
return credMap, enabledRegs
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
index d5096a099..51ba9d0a0 100644
--- a/backend/internal/services/image_update_service_test.go
+++ b/backend/internal/services/image_update_service_test.go
@@ -7,8 +7,11 @@ import (
"time"
dockertypesimage "github.com/docker/docker/api/types/image"
+ "github.com/getarcaneapp/arcane/backend/internal/config"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"
+ "github.com/getarcaneapp/arcane/types/containerregistry"
"github.com/getarcaneapp/arcane/types/imageupdate"
glsqlite "github.com/glebarez/sqlite"
"github.com/stretchr/testify/assert"
@@ -757,6 +760,70 @@ func TestImageUpdateService_ParseAndGroupImages_DedupesNormalizedRefs(t *testing
containsAll(firstRefSet, "redis:7", "docker.io/library/redis:7")))
}
+func TestImageUpdateService_BuildCredentialMap_ExternalCredsDedupesEnabledRegistriesByHost(t *testing.T) {
+ crypto.InitEncryption(&config.Config{
+ Environment: config.AppEnvironmentTest,
+ EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
+ })
+
+ svc := &ImageUpdateService{}
+ ctx := context.Background()
+
+ externalCreds := []containerregistry.Credential{
+ {URL: "https://ghcr.io", Username: "first-user", Token: "first-token", Enabled: true},
+ {URL: "ghcr.io/", Username: "second-user", Token: "second-token", Enabled: true},
+ {URL: "https://docker.io", Username: "docker-user", Token: "docker-token", Enabled: true},
+ }
+
+ credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)
+
+ require.Len(t, credMap, 2)
+ require.Len(t, enabledRegs, 2)
+
+ // Keep first credential per normalized host for token exchange calls.
+ assert.Equal(t, "first-user", credMap["ghcr.io"].username)
+ assert.Equal(t, "first-token", credMap["ghcr.io"].token)
+ assert.Equal(t, "docker-user", credMap["docker.io"].username)
+ assert.Equal(t, "docker-token", credMap["docker.io"].token)
+
+ // Enabled registry records used for auth fallback should be de-duplicated per host.
+ enabledByHost := make(map[string]models.ContainerRegistry, len(enabledRegs))
+ for _, reg := range enabledRegs {
+ host := svc.normalizeRegistryURL(reg.URL)
+ enabledByHost[host] = reg
+ }
+ require.Contains(t, enabledByHost, "ghcr.io")
+ require.Contains(t, enabledByHost, "docker.io")
+
+ assert.Equal(t, "first-user", enabledByHost["ghcr.io"].Username)
+ assert.NotEmpty(t, enabledByHost["ghcr.io"].Token)
+ assert.Equal(t, "docker-user", enabledByHost["docker.io"].Username)
+ assert.NotEmpty(t, enabledByHost["docker.io"].Token)
+}
+
+func TestImageUpdateService_BuildCredentialMap_ExternalCredsSkipsInvalidEntries(t *testing.T) {
+ crypto.InitEncryption(&config.Config{
+ Environment: config.AppEnvironmentTest,
+ EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
+ })
+
+ svc := &ImageUpdateService{}
+ ctx := context.Background()
+
+ externalCreds := []containerregistry.Credential{
+ {URL: "https://ghcr.io", Username: "valid-user", Token: "valid-token", Enabled: true},
+ {URL: "https://ghcr.io", Username: "", Token: "missing-user", Enabled: true},
+ {URL: "https://ghcr.io", Username: "disabled", Token: "disabled-token", Enabled: false},
+ {URL: "", Username: "missing-url", Token: "token", Enabled: true},
+ }
+
+ credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)
+
+ require.Len(t, credMap, 1)
+ require.Len(t, enabledRegs, 1)
+ assert.Equal(t, "valid-user", credMap["ghcr.io"].username)
+}
+
func TestDedupeImageRefsFromSummaries_WithLimit(t *testing.T) {
summaries := []dockertypesimage.Summary{
{RepoTags: []string{"nginx:latest", "nginx:latest", "<none>:<none>"}},
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index f151e348b..2374bf3ca 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -8,6 +8,7 @@ import (
"log/slog"
"slices"
"strings"
+ "sync"
"time"
"github.com/compose-spec/compose-go/v2/loader"
@@ -37,6 +38,7 @@ type UpdaterService struct {
notificationService *NotificationService
upgradeService *SystemUpgradeService
+ statusMu sync.RWMutex
updatingContainers map[string]bool
updatingProjects map[string]bool
}
@@ -439,6 +441,11 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID
"isArcane", isArcaneContainer,
"hasArcaneLabel", labels["com.getarcaneapp.arcane"])
+ endContainerStatus := s.beginContainerUpdateInternal(targetContainer.ID)
+ defer endContainerStatus()
+ endProjectStatus := s.beginProjectUpdateInternal(composeProjectNameFromLabelsInternal(labels))
+ defer endProjectStatus()
+
if arcaneupdater.IsUpdateDisabled(labels) {
slog.InfoContext(ctx, "UpdateSingleContainer: updates disabled by label", "containerID", containerID)
out.Items = append(out.Items, updater.ResourceResult{
@@ -643,23 +650,7 @@ func (s *UpdaterService) pruneImageIDsWithInUseSetInternal(ctx context.Context,
return nil
}
-func (s *UpdaterService) GetStatus() updater.Status {
- containerIDs := make([]string, 0, len(s.updatingContainers))
- for id := range s.updatingContainers {
- containerIDs = append(containerIDs, id)
- }
- projectIDs := make([]string, 0, len(s.updatingProjects))
- for id := range s.updatingProjects {
- projectIDs = append(projectIDs, id)
- }
-
- return updater.Status{
- UpdatingContainers: len(s.updatingContainers),
- UpdatingProjects: len(s.updatingProjects),
- ContainerIds: containerIDs,
- ProjectIds: projectIDs,
- }
-}
+func (s *UpdaterService) GetStatus() updater.Status { return s.statusSnapshotInternal() }
func (s *UpdaterService) GetHistory(ctx context.Context, limit int) ([]models.AutoUpdateRecord, error) {
var rec []models.AutoUpdateRecord
@@ -1263,43 +1254,112 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
slog.DebugContext(ctx, "restartContainersUsingOldIDs: restarting container", "containerId", p.cnt.ID, "container", name, "match", p.match, "newRef", p.newRef, "implicit", p.implicit)
- // Check if this is Arcane self-update - use CLI upgrade instead
- if arcaneupdater.IsArcaneContainer(labels) && s.upgradeService != nil {
- slog.InfoContext(ctx, "restartContainersUsingOldIDs: detected Arcane self-update, using CLI upgrade method", "containerId", p.cnt.ID, "container", name)
-
- if err := s.upgradeService.TriggerUpgradeViaCLI(ctx, systemUser); err != nil {
+ func() {
+ endContainerStatus := s.beginContainerUpdateInternal(p.cnt.ID)
+ defer endContainerStatus()
+ endProjectStatus := s.beginProjectUpdateInternal(composeProjectNameFromLabelsInternal(labels))
+ defer endProjectStatus()
+
+ // Check if this is Arcane self-update - use CLI upgrade instead
+ if arcaneupdater.IsArcaneContainer(labels) && s.upgradeService != nil {
+ slog.InfoContext(ctx, "restartContainersUsingOldIDs: detected Arcane self-update, using CLI upgrade method", "containerId", p.cnt.ID, "container", name)
+
+ if err := s.upgradeService.TriggerUpgradeViaCLI(ctx, systemUser); err != nil {
+ res.Status = "failed"
+ res.Error = fmt.Sprintf("CLI upgrade failed: %v", err)
+ slog.WarnContext(ctx, "restartContainersUsingOldIDs: CLI upgrade failed", "containerId", p.cnt.ID, "err", err)
+ } else {
+ res.Status = "updated"
+ res.UpdateAvailable = true
+ res.UpdateApplied = true
+ slog.InfoContext(ctx, "restartContainersUsingOldIDs: CLI upgrade triggered successfully", "containerId", p.cnt.ID)
+ }
+ } else if err := s.updateContainer(ctx, p.cnt, *p.inspect, p.newRef); err != nil {
res.Status = "failed"
- res.Error = fmt.Sprintf("CLI upgrade failed: %v", err)
- slog.WarnContext(ctx, "restartContainersUsingOldIDs: CLI upgrade failed", "containerId", p.cnt.ID, "err", err)
+ res.Error = err.Error()
+ slog.DebugContext(ctx, "restartContainersUsingOldIDs: update failed", "containerId", p.cnt.ID, "err", err)
} else {
res.Status = "updated"
res.UpdateAvailable = true
res.UpdateApplied = true
- slog.InfoContext(ctx, "restartContainersUsingOldIDs: CLI upgrade triggered successfully", "containerId", p.cnt.ID)
- }
- } else if err := s.updateContainer(ctx, p.cnt, *p.inspect, p.newRef); err != nil {
- res.Status = "failed"
- res.Error = err.Error()
- slog.DebugContext(ctx, "restartContainersUsingOldIDs: update failed", "containerId", p.cnt.ID, "err", err)
- } else {
- res.Status = "updated"
- res.UpdateAvailable = true
- res.UpdateApplied = true
- slog.DebugContext(ctx, "restartContainersUsingOldIDs: update succeeded", "containerId", p.cnt.ID)
-
- // Send notification after successful container update
- if s.notificationService != nil {
- if notifErr := s.notificationService.SendContainerUpdateNotification(ctx, name, p.newRef, p.match, s.normalizeRef(p.newRef)); notifErr != nil {
- slog.WarnContext(ctx, "Failed to send container update notification", "containerId", p.cnt.ID, "containerName", name, "imageRef", p.newRef, "error", notifErr.Error())
+ slog.DebugContext(ctx, "restartContainersUsingOldIDs: update succeeded", "containerId", p.cnt.ID)
+
+ // Send notification after successful container update
+ if s.notificationService != nil {
+ if notifErr := s.notificationService.SendContainerUpdateNotification(ctx, name, p.newRef, p.match, s.normalizeRef(p.newRef)); notifErr != nil {
+ slog.WarnContext(ctx, "Failed to send container update notification", "containerId", p.cnt.ID, "containerName", name, "imageRef", p.newRef, "error", notifErr.Error())
+ }
}
}
- }
+ }()
results = append(results, res)
}
slog.DebugContext(ctx, "restartContainersUsingOldIDs: completed scanning", "results", len(results))
return results, nil
}
+func (s *UpdaterService) beginContainerUpdateInternal(containerID string) func() {
+ containerID = strings.TrimSpace(containerID)
+ if containerID == "" {
+ return func() {}
+ }
+
+ s.statusMu.Lock()
+ s.updatingContainers[containerID] = true
+ s.statusMu.Unlock()
+
+ return func() {
+ s.statusMu.Lock()
+ delete(s.updatingContainers, containerID)
+ s.statusMu.Unlock()
+ }
+}
+
+func (s *UpdaterService) beginProjectUpdateInternal(projectID string) func() {
+ projectID = strings.TrimSpace(projectID)
+ if projectID == "" {
+ return func() {}
+ }
+
+ s.statusMu.Lock()
+ s.updatingProjects[projectID] = true
+ s.statusMu.Unlock()
+
+ return func() {
+ s.statusMu.Lock()
+ delete(s.updatingProjects, projectID)
+ s.statusMu.Unlock()
+ }
+}
+
+func composeProjectNameFromLabelsInternal(labels map[string]string) string {
+ if len(labels) == 0 {
+ return ""
+ }
+ return strings.TrimSpace(labels["com.docker.compose.project"])
+}
+
+func (s *UpdaterService) statusSnapshotInternal() updater.Status {
+ s.statusMu.RLock()
+ defer s.statusMu.RUnlock()
+
+ containerIDs := make([]string, 0, len(s.updatingContainers))
+ for id := range s.updatingContainers {
+ containerIDs = append(containerIDs, id)
+ }
+ projectIDs := make([]string, 0, len(s.updatingProjects))
+ for id := range s.updatingProjects {
+ projectIDs = append(projectIDs, id)
+ }
+
+ return updater.Status{
+ UpdatingContainers: len(s.updatingContainers),
+ UpdatingProjects: len(s.updatingProjects),
+ ContainerIds: containerIDs,
+ ProjectIds: projectIDs,
+ }
+}
+
func (s *UpdaterService) resolveContainerImageMatchInternal(c container.Summary, oldIDToNewRef map[string]string, updatedNorm map[string]string) (newRef, match string) {
if c.ImageID != "" {
if nr, ok := oldIDToNewRef[c.ImageID]; ok {
diff --git a/backend/internal/services/updater_service_test.go b/backend/internal/services/updater_service_test.go
index ba16df9db..0cce3fb63 100644
--- a/backend/internal/services/updater_service_test.go
+++ b/backend/internal/services/updater_service_test.go
@@ -473,3 +473,36 @@ func TestResolveContainerImageMatchInternal(t *testing.T) {
})
}
}
+
+func TestUpdaterService_StatusTrackingInternal(t *testing.T) {
+ svc := &UpdaterService{
+ updatingContainers: map[string]bool{},
+ updatingProjects: map[string]bool{},
+ }
+
+ stopContainer := svc.beginContainerUpdateInternal("container-1")
+ stopProject := svc.beginProjectUpdateInternal("project-a")
+
+ status := svc.GetStatus()
+ assert.Equal(t, 1, status.UpdatingContainers)
+ assert.Equal(t, 1, status.UpdatingProjects)
+ assert.ElementsMatch(t, []string{"container-1"}, status.ContainerIds)
+ assert.ElementsMatch(t, []string{"project-a"}, status.ProjectIds)
+
+ stopContainer()
+ stopProject()
+
+ status = svc.GetStatus()
+ assert.Zero(t, status.UpdatingContainers)
+ assert.Zero(t, status.UpdatingProjects)
+ assert.Empty(t, status.ContainerIds)
+ assert.Empty(t, status.ProjectIds)
+}
+
+func TestComposeProjectNameFromLabelsInternal(t *testing.T) {
+ assert.Equal(t, "", composeProjectNameFromLabelsInternal(nil))
+ assert.Equal(t, "", composeProjectNameFromLabelsInternal(map[string]string{}))
+ assert.Equal(t, "my-project", composeProjectNameFromLabelsInternal(map[string]string{
+ "com.docker.compose.project": " my-project ",
+ }))
+}