Skip to content

Modern Docker Management, Designed for Everyone

fix: harden backend stability and attestation fetches (#4491)

Kyle Mendelldac409fc372b
diff --git a/backend/internal/activity/service_test.go b/backend/internal/activity/service_test.go
index 3c0a44e9f..82a2e20af 100644
--- a/backend/internal/activity/service_test.go
+++ b/backend/internal/activity/service_test.go
@@ -18,6 +18,7 @@ import (
"go.getarcane.app/sys/crypto"
"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/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/gitrepo"
@@ -349,7 +350,7 @@ func setupQueuedActivityService(t *testing.T) (*ActivityService, *settings.Setti
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/apns/service.go b/backend/internal/apns/service.go
index 99e58f585..b6a10558f 100644
--- a/backend/internal/apns/service.go
+++ b/backend/internal/apns/service.go
@@ -55,11 +55,14 @@ type ApnsService struct {
events *event.EventService
httpClient *http.Client
+ lifecycleCtx context.Context
+ channelMu sync.Mutex
drainMu sync.Mutex
drainPending atomic.Bool
}
func NewApnsService(
+ lifecycleCtx context.Context,
db *database.DB,
cfg *config.Config,
settingsService *settings.SettingsService,
@@ -67,7 +70,15 @@ func NewApnsService(
eventService *event.EventService,
httpClient *http.Client,
) *ApnsService {
- return &ApnsService{db: db, config: cfg, settings: settingsService, roles: roleService, events: eventService, httpClient: httpClient}
+ return &ApnsService{
+ db: db,
+ config: cfg,
+ settings: settingsService,
+ roles: roleService,
+ events: eventService,
+ httpClient: httpClient,
+ lifecycleCtx: lifecycleCtx,
+ }
}
func (s *ApnsService) Enabled(ctx context.Context) bool {
@@ -164,6 +175,8 @@ func (s *ApnsService) EnsureChannel(ctx context.Context) (string, error) {
if !s.Enabled(ctx) {
return "", common.ErrApnsDisabled
}
+ s.channelMu.Lock()
+ defer s.channelMu.Unlock()
if channelID := s.settings.GetStringSetting(ctx, "apnsChannelId", ""); channelID != "" {
return channelID, nil
}
@@ -216,6 +229,8 @@ func (s *ApnsService) ApplyEnabledUpdates(ctx context.Context, updates []libarca
}
func (s *ApnsService) RevokeChannel(ctx context.Context) error {
+ s.channelMu.Lock()
+ defer s.channelMu.Unlock()
channelID := s.settings.GetStringSetting(ctx, "apnsChannelId", "")
if channelID != "" {
signer, err := s.signerInternal(ctx)
@@ -508,9 +523,8 @@ func (s *ApnsService) Enqueue(ctx context.Context, environmentID, environmentNam
return false, fmt.Errorf("failed to enqueue push notification: %w", enqueueNotificationErr)
}
go func() {
- drainCtx := context.WithoutCancel(ctx)
- if drainOutboxErr := s.DrainOutbox(drainCtx); drainOutboxErr != nil {
- slog.WarnContext(drainCtx, "Push outbox drain failed", "error", drainOutboxErr)
+ if drainOutboxErr := s.DrainOutbox(s.lifecycleCtx); drainOutboxErr != nil && s.lifecycleCtx.Err() == nil {
+ slog.WarnContext(s.lifecycleCtx, "Push outbox drain failed", "error", drainOutboxErr)
}
}()
return true, nil
@@ -550,14 +564,17 @@ func (s *ApnsService) recipientsInternal(ctx context.Context, environmentID stri
func (s *ApnsService) DrainOutbox(ctx context.Context) error {
s.drainPending.Store(true)
- if !s.drainMu.TryLock() {
- return nil
- }
- defer s.drainMu.Unlock()
- for s.drainPending.Swap(false) {
- if err := s.drainOutboxInternal(ctx); err != nil {
- return err
+ for s.drainPending.Load() {
+ if !s.drainMu.TryLock() {
+ return nil
+ }
+ for s.drainPending.Swap(false) {
+ if err := s.drainOutboxInternal(ctx); err != nil {
+ s.drainMu.Unlock()
+ return err
+ }
}
+ s.drainMu.Unlock()
}
return nil
}
diff --git a/backend/internal/appimages/handler.go b/backend/internal/appimages/handler.go
index c97b4ca8b..2873b8742 100644
--- a/backend/internal/appimages/handler.go
+++ b/backend/internal/appimages/handler.go
@@ -2,11 +2,14 @@ package appimages
import (
"context"
+ "errors"
"path/filepath"
"strings"
"github.com/danielgtaylor/huma/v2"
"go.getarcane.app/kit/pkg"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
)
// AppImagesHandler provides Huma-based application image endpoints.
@@ -80,6 +83,9 @@ func (h *AppImagesHandler) GetPWAIcon(ctx context.Context, input *GetPWAIconInpu
func (h *AppImagesHandler) getImageWithColor(name, colorOverride string, loop bool) (*GetAppImageOutput, error) {
imageData, mimeType, err := h.appImagesService.GetImageWithColor(name, colorOverride, loop)
if err != nil {
+ if errors.Is(err, common.ErrNotFound) {
+ return nil, huma.Error404NotFound(err.Error())
+ }
return nil, huma.Error500InternalServerError("Failed to retrieve image: " + err.Error())
}
diff --git a/backend/internal/appimages/service.go b/backend/internal/appimages/service.go
index 9df488428..dd3624b5f 100644
--- a/backend/internal/appimages/service.go
+++ b/backend/internal/appimages/service.go
@@ -11,6 +11,7 @@ import (
settingstypes "github.com/getarcaneapp/arcane/types/v2/settings"
"go.getarcane.app/kit/pkg"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
)
@@ -75,7 +76,7 @@ func (s *ApplicationImagesService) GetImageWithColor(name, colorOverride string,
img, ok = dev, true
}
if !ok {
- return nil, "", fmt.Errorf("image '%s' not found", name)
+ return nil, "", common.Classify(common.ErrNotFound, fmt.Errorf("image '%s' not found", name))
}
data, mimeType := img.data, img.mimeType
diff --git a/backend/internal/appimages/service_test.go b/backend/internal/appimages/service_test.go
index 2661df3e9..b90311d46 100644
--- a/backend/internal/appimages/service_test.go
+++ b/backend/internal/appimages/service_test.go
@@ -27,7 +27,7 @@ func newServiceForVersion(t *testing.T, version string) (*ApplicationImagesServi
gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}))
- settingsSvc, err := settings.NewSettingsService(t.Context(), &database.DB{DB: gdb})
+ settingsSvc, err := settings.NewSettingsService(t.Context(), &database.DB{DB: gdb}, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsSvc.Stop(context.WithoutCancel(t.Context()))) })
diff --git a/backend/internal/auth/service_test.go b/backend/internal/auth/service_test.go
index 535924167..593034f1f 100644
--- a/backend/internal/auth/service_test.go
+++ b/backend/internal/auth/service_test.go
@@ -54,7 +54,7 @@ func setupAuthServiceTestDB(t *testing.T) *database.DB {
func newSettingsServiceForAuthTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index d555b336e..d5e5fce5d 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -16,7 +16,6 @@ import (
"github.com/labstack/echo/v5"
"github.com/moby/moby/client"
"github.com/subosito/gotenv"
- kit "go.getarcane.app/kit/pkg"
"go.getarcane.app/sys/crypto"
"go.opentelemetry.io/contrib/bridges/otelslog"
"go.uber.org/fx"
@@ -42,6 +41,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/startup"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/tracing"
@@ -148,10 +148,10 @@ func applicationOptions(appCtx context.Context, cfg *config.Config, db *database
fx.Supply(cfg, db, cancelApp),
fx.Provide(
func() context.Context { return appCtx },
- func(cfg *config.Config) *http.Client {
+ func(settingsService *settings.SettingsService) *http.Client {
return httpx.NewHTTPClient(httpxtypes.ClientOptions{
- Timeout: kit.Ternary(cfg.HTTPClientTimeout > 0, time.Duration(cfg.HTTPClientTimeout)*time.Second, 10*time.Second),
- TLSHandshakeTimeout: kit.Ternary(cfg.HTTPClientTimeout > 0, 10*time.Second, 5*time.Second),
+ Timeout: timeouts.GetDuration(settingsService.GetSettingsOrDefaults(appCtx).HTTPClientTimeout.AsInt(), timeouts.DefaultHTTPClient),
+ TLSHandshakeTimeout: 10 * time.Second,
})
},
),
@@ -250,6 +250,9 @@ func initializeStartupState(p initializeStartupStateParams) {
Environment: string(cfg.Environment),
AgentMode: cfg.AgentMode,
})
+ if reloadErr := p.Settings.LoadDatabaseSettings(appCtx); reloadErr != nil {
+ slog.WarnContext(appCtx, "Failed to reload settings after initializing encryption", "error", reloadErr)
+ }
startup.InitializeDefaultSettings(appCtx, runtimeCfg, p.Settings)
// Startup repairs are best-effort: log each failure and continue.
@@ -261,6 +264,7 @@ func initializeStartupState(p initializeStartupStateParams) {
return p.Settings.NormalizeProjectsDirectory(ctx, cfg.ProjectsDirectory)
}},
{name: "normalize builds directory", run: p.Settings.NormalizeBuildsDirectory},
+ {name: "encrypt stored sensitive settings", run: p.Settings.EncryptStoredSensitiveSettings},
{name: "ensure local environment", run: func(ctx context.Context) error { return p.Environment.EnsureLocalEnvironment(ctx, cfg.AppUrl) }},
{name: "clean up orphaned GitOps syncs", run: p.GitOpsSync.CleanupOrphanedSyncsOnStartup},
{name: "clean up leaked GitOps scratch directories", run: p.GitOpsSync.CleanupLeakedScratchDirsOnStartup},
diff --git a/backend/internal/build/children/workspace/service_test.go b/backend/internal/build/children/workspace/service_test.go
index 673c39b22..c64c3c39c 100644
--- a/backend/internal/build/children/workspace/service_test.go
+++ b/backend/internal/build/children/workspace/service_test.go
@@ -10,6 +10,7 @@ import (
"github.com/stretchr/testify/require"
"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/settings"
)
@@ -44,7 +45,7 @@ func setupSettingsTestDB(t *testing.T) *database.DB {
func newSettingsServiceForTestInternal(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go
index 3810e4a41..838e1d891 100644
--- a/backend/internal/config/config.go
+++ b/backend/internal/config/config.go
@@ -102,16 +102,15 @@ type Config struct {
EdgeMTLSServerName string `env:"EDGE_MTLS_SERVER_NAME" default:""`
EdgeMTLSAssetsDir string `env:"EDGE_MTLS_ASSETS_DIR" default:""`
- TrustedProxies string `env:"TRUSTED_PROXIES" default:""`
- FilePerm os.FileMode `env:"FILE_PERM" default:"0644"`
- DirPerm os.FileMode `env:"DIR_PERM" default:"0755"`
- GitWorkDir string `env:"GIT_WORK_DIR" default:"data/git"`
- HTTPClientTimeout int `env:"HTTP_CLIENT_TIMEOUT" default:"0"`
- BackupVolumeName string `env:"ARCANE_BACKUP_VOLUME_NAME" default:"arcane-backups"`
- HTTPProxy string `env:"HTTP_PROXY" default:""`
- HTTPSProxy string `env:"HTTPS_PROXY" default:""`
- NoProxy string `env:"NO_PROXY" default:""`
- Timezone string `env:"TZ" default:"Local"`
+ TrustedProxies string `env:"TRUSTED_PROXIES" default:""`
+ FilePerm os.FileMode `env:"FILE_PERM" default:"0644"`
+ DirPerm os.FileMode `env:"DIR_PERM" default:"0755"`
+ GitWorkDir string `env:"GIT_WORK_DIR" default:"data/git"`
+ BackupVolumeName string `env:"ARCANE_BACKUP_VOLUME_NAME" default:"arcane-backups"`
+ HTTPProxy string `env:"HTTP_PROXY" default:""`
+ HTTPSProxy string `env:"HTTPS_PROXY" default:""`
+ NoProxy string `env:"NO_PROXY" default:""`
+ Timezone string `env:"TZ" default:"Local"`
}
func Load() *Config {
diff --git a/backend/internal/config/schema/schema_test.go b/backend/internal/config/schema/schema_test.go
index 67833993c..b5a1e7de4 100644
--- a/backend/internal/config/schema/schema_test.go
+++ b/backend/internal/config/schema/schema_test.go
@@ -231,7 +231,6 @@ var expectedEnvConfigVars = []string{
"GPU_MONITORING_ENABLED",
"GPU_TYPE",
"HTTPS_PROXY",
- "HTTP_CLIENT_TIMEOUT",
"HTTP_PROXY",
"JWT_REFRESH_EXPIRY",
"JWT_SECRET",
diff --git a/backend/internal/container/service_test.go b/backend/internal/container/service_test.go
index 5dca416b1..e8905e3f4 100644
--- a/backend/internal/container/service_test.go
+++ b/backend/internal/container/service_test.go
@@ -35,6 +35,7 @@ import (
"go.getarcane.app/kit/pkg"
"gorm.io/gorm"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/container/children/stats"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
@@ -143,7 +144,7 @@ func TestPaginateContainerProjectGroupsSelectsRequestedPage(t *testing.T) {
func TestContainerSummaryIconsAppliedAfterGrouping(t *testing.T) {
db := setupProjectTestDB(t)
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
service := NewContainerService(nil, nil, nil, settingsService, project.NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, nil, nil, nil), nil)
dockerContainers := []container.Summary{
@@ -227,7 +228,7 @@ func TestBuildContainerFilterAccessors_FiltersByLabel(t *testing.T) {
{ID: "other", Labels: map[string]string{"heal": "false"}},
{ID: "bare", Labels: map[string]string{}},
}
- config := pagination.Config[containertypes.Summary]{FilterAccessors: service.buildContainerPaginationConfig().FilterAccessors}
+ paginationConfig := pagination.Config[containertypes.Summary]{FilterAccessors: service.buildContainerPaginationConfig().FilterAccessors}
tests := []struct {
name string
@@ -242,7 +243,7 @@ func TestBuildContainerFilterAccessors_FiltersByLabel(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- result := config.SearchOrderAndPaginate(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}})
+ result := paginationConfig.SearchOrderAndPaginate(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}})
var got []string
for _, item := range result.Items {
got = append(got, item.ID)
@@ -891,7 +892,7 @@ func TestRecoverInterruptedRedeploys(t *testing.T) {
}
func TestBuildSummariesUsesContainerTagPolicyUpdates(t *testing.T) {
- settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t))
+ settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
require.NoError(t, err)
service := NewContainerService(nil, nil, nil, settingsService, nil, nil)
strategyLabel := "com.getarcaneapp.arcane.updater.strategy"
@@ -1003,7 +1004,7 @@ func TestContainerServiceGetContainerProcesses(t *testing.T) {
}
}))
t.Cleanup(server.Close)
- settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t))
+ settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
require.NoError(t, err)
svc := NewContainerService(nil, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, settingsService, nil, nil)
@@ -1031,7 +1032,7 @@ func TestContainerServiceGetContainerProcessesPropagatesContext(t *testing.T) {
close(requestDone)
}))
t.Cleanup(server.Close)
- settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t))
+ settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
require.NoError(t, err)
svc := NewContainerService(nil, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, settingsService, nil, nil)
@@ -1172,7 +1173,7 @@ func newResourceSortService(t *testing.T, fixture *resourceStatsServer) *Contain
t.Cleanup(server.Close)
db := setupProjectTestDB(t)
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
dockerService := docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server))
return NewContainerService(
diff --git a/backend/internal/dashboard/service_test.go b/backend/internal/dashboard/service_test.go
index 03edded9c..d5a73852e 100644
--- a/backend/internal/dashboard/service_test.go
+++ b/backend/internal/dashboard/service_test.go
@@ -52,7 +52,7 @@ func setupDashboardServiceTestDB(t *testing.T) (*database.DB, *settings.Settings
require.NoError(t, db.AutoMigrate(&apikey.ApiKey{}, &environment.Environment{}, &imageupdate.ImageUpdateRecord{}, &project.Project{}, &settings.SettingVariable{}))
databaseDB := &database.DB{DB: db}
- settingsSvc, err := settings.NewSettingsService(t.Context(), databaseDB)
+ settingsSvc, err := settings.NewSettingsService(t.Context(), databaseDB, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsSvc.Stop(context.WithoutCancel(t.Context()))) })
diff --git a/backend/internal/di/providers.go b/backend/internal/di/providers.go
index c16059591..fab41632b 100644
--- a/backend/internal/di/providers.go
+++ b/backend/internal/di/providers.go
@@ -418,6 +418,7 @@ func provideSystemService(
versionService *version.VersionService,
eventService *event.EventService,
projectService *project.ProjectService,
+ registryService *registry.ContainerRegistryService,
backupEngine *backup.Engine,
s3Destinations *s3domain.S3DestinationService,
recoveryKeys *backup.RecoveryKeyStore,
@@ -429,7 +430,7 @@ func provideSystemService(
) (*system.SystemService, error) {
service := system.NewSystemService(
db, dockerService, containerService, imageUpdateService, volumeService, networkService, settingsService, activityService,
- versionService, eventService, projectService, backupEngine, s3Destinations, recoveryKeys, actors, cfg,
+ versionService, eventService, projectService, registryService, backupEngine, s3Destinations, recoveryKeys, actors, cfg,
)
if err := service.RegisterWorkflows(engine, environments, roles); err != nil {
return nil, err
diff --git a/backend/internal/federated/service_test.go b/backend/internal/federated/service_test.go
index a0947fc86..a5c7bbdbb 100644
--- a/backend/internal/federated/service_test.go
+++ b/backend/internal/federated/service_test.go
@@ -382,7 +382,7 @@ func TestFederatedCredentialServiceCreateRejectsBareWildcardGlob(t *testing.T) {
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/gitops/children/sync/service_test.go b/backend/internal/gitops/children/sync/service_test.go
index 6b3d30255..c9a4f0f58 100644
--- a/backend/internal/gitops/children/sync/service_test.go
+++ b/backend/internal/gitops/children/sync/service_test.go
@@ -47,7 +47,7 @@ func setupSyncTestService(t *testing.T) (*Service, *database.DB, string) {
require.NoError(t, db.AutoMigrate(&projectpkg.Project{}, &projectpkg.GitOpsSync{}, &settings.SettingVariable{}, &imageupdate.ImageUpdateRecord{}, &event.Event{}))
arcaneDB := &database.DB{DB: db}
- settingsService, err := settings.NewSettingsService(ctx, arcaneDB)
+ settingsService, err := settings.NewSettingsService(ctx, arcaneDB, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
diff --git a/backend/internal/gitops/service_test.go b/backend/internal/gitops/service_test.go
index 310affd9f..42a7b5471 100644
--- a/backend/internal/gitops/service_test.go
+++ b/backend/internal/gitops/service_test.go
@@ -65,7 +65,7 @@ func setupGitOpsProjectTestDB(t *testing.T) *database.DB {
func newGitOpsSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- service, err := settings.NewSettingsService(ctx, db)
+ service, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, service.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/gitrepo/service_test.go b/backend/internal/gitrepo/service_test.go
index 736284b5a..7230e383f 100644
--- a/backend/internal/gitrepo/service_test.go
+++ b/backend/internal/gitrepo/service_test.go
@@ -61,7 +61,7 @@ func setupGitRepositoryServiceTestInternal(t *testing.T) *GitRepositoryService {
func newSettingsServiceForTestInternal(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/image/children/attestations/handler.go b/backend/internal/image/children/attestations/handler.go
index d08c3c21a..fbd4aa4e4 100644
--- a/backend/internal/image/children/attestations/handler.go
+++ b/backend/internal/image/children/attestations/handler.go
@@ -2,7 +2,10 @@ package attestations
import (
"context"
+ "errors"
"fmt"
+ "log/slog"
+ "net/http"
"strings"
"github.com/containerd/platforms"
@@ -10,9 +13,12 @@ import (
"github.com/getarcaneapp/arcane/types/v2/base"
"github.com/getarcaneapp/arcane/types/v2/image"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
)
+const statusClientClosedRequest = 499
+
// Handler serves image attestation endpoints.
type Handler struct {
service *Service
@@ -49,7 +55,14 @@ func (h *Handler) GetImageAttestations(ctx context.Context, input *GetImageAttes
IncludeStatement: input.WithStatement,
})
if err != nil {
- return nil, huma.Error500InternalServerError(fmt.Sprintf("failed to get image attestations: %v", err))
+ if errors.Is(err, context.Canceled) {
+ return nil, huma.NewError(statusClientClosedRequest, "request canceled")
+ }
+ if apiErr := common.ToAPIError(err); apiErr.HTTPStatus() != http.StatusInternalServerError {
+ return nil, huma.NewError(apiErr.HTTPStatus(), apiErr.Message)
+ }
+ slog.ErrorContext(ctx, "failed to get image attestations", "image", imageName, "error", err)
+ return nil, huma.Error500InternalServerError("failed to get image attestations")
}
return &handlerutil.Out[image.AttestationList]{
diff --git a/backend/internal/image/children/attestations/service.go b/backend/internal/image/children/attestations/service.go
index 0454853ab..bf4db2ff2 100644
--- a/backend/internal/image/children/attestations/service.go
+++ b/backend/internal/image/children/attestations/service.go
@@ -28,23 +28,39 @@ import (
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"go.getarcane.app/kit/pkg"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/registryauth"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
)
const (
dockerAttestationManifestArtifactType = "application/vnd.docker.attestation.manifest.v1+json"
inTotoLayerMediaType = "application/vnd.in-toto+json"
inTotoPredicateTypeAnnotation = "in-toto.io/predicate-type"
+ maxAttestationLayerBytes = 16 << 20
)
// zstdDecoder is shared because DecodeAll is safe for concurrent use and a decoder is costly to build.
-var zstdDecoder = sync.OnceValues(func() (*zstd.Decoder, error) { return zstd.NewReader(nil) })
+var zstdDecoder = sync.OnceValues(func() (*zstd.Decoder, error) {
+ return zstd.NewReader(nil, zstd.WithDecoderMaxMemory(maxAttestationLayerBytes))
+})
+
+var safeRegistryTransport = sync.OnceValues(func() (http.RoundTripper, error) {
+ safeClient, err := httpx.NewSafeOutboundHTTPClient(nil, httpx.DefaultLookupIP)
+ if err != nil {
+ return nil, err
+ }
+ return safeClient.Transport, nil
+})
+
+var errAttestationLayerTooLarge = common.Classify(common.ErrBadRequest, fmt.Errorf("attestation layer exceeds the %d MiB limit", maxAttestationLayerBytes>>20))
// Service reads in-toto attestations attached to local images and registry references.
type Service struct {
dockerService *docker.DockerClientService
- registryAuth func(ctx context.Context, registryHost string) (string, error)
+ registryAuth func(ctx context.Context, imageRef string) (string, error)
}
type Query struct {
@@ -57,6 +73,7 @@ type reference struct {
ImageRef string
SubjectDigest string
Empty bool
+ External bool
}
type subject struct {
@@ -73,13 +90,16 @@ type attestationStatementEnvelope struct {
func NewService(
dockerService *docker.DockerClientService,
- registryAuth func(ctx context.Context, registryHost string) (string, error),
+ registryAuth func(ctx context.Context, imageRef string) (string, error),
) *Service {
return &Service{dockerService: dockerService, registryAuth: registryAuth}
}
// GetImageAttestations returns in-toto attestations attached to a local image or registry reference.
func (s *Service) GetImageAttestations(ctx context.Context, imageName string, query Query) (*image.AttestationList, error) {
+ ctx, cancel := context.WithTimeout(ctx, timeouts.DefaultRegistry)
+ defer cancel()
+
resolution, err := s.resolveImageAttestationReference(ctx, imageName)
if err != nil {
return nil, err
@@ -100,7 +120,7 @@ func (s *Service) GetImageAttestations(ctx context.Context, imageName string, qu
}
parsed, parseErr := platforms.Parse(value)
if parseErr != nil {
- return ocispec.Platform{}, false, fmt.Errorf("invalid platform %q: %w", value, parseErr)
+ return ocispec.Platform{}, false, common.Classify(common.ErrBadRequest, fmt.Errorf("invalid platform %q: %w", value, parseErr))
}
return parsed, true, nil
}()
@@ -110,13 +130,16 @@ func (s *Service) GetImageAttestations(ctx context.Context, imageName string, qu
ref, err := name.ParseReference(resolution.ImageRef, name.WeakValidation)
if err != nil {
- return nil, fmt.Errorf("parse image reference %q: %w", resolution.ImageRef, err)
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("parse image reference %q: %w", resolution.ImageRef, err))
}
- remoteOptions := s.remoteOptionsForImageRef(ctx, resolution.ImageRef)
+ remoteOptions, err := s.remoteOptionsForImageRef(ctx, resolution)
+ if err != nil {
+ return nil, err
+ }
remoteDescriptor, err := remote.Get(ref, remoteOptions...)
if err != nil {
- return nil, fmt.Errorf("get image manifest %q: %w", resolution.ImageRef, err)
+ return nil, classifyRegistryError(ctx, fmt.Errorf("get image manifest %q: %w", resolution.ImageRef, err))
}
index, targets, err := subjects(remoteDescriptor, platform, hasPlatform)
@@ -196,18 +219,15 @@ func (s *Service) GetImageAttestations(ctx context.Context, imageName string, qu
func (s *Service) resolveImageAttestationReference(ctx context.Context, imageName string) (reference, error) {
imageName = strings.TrimSpace(imageName)
if imageName == "" {
- return reference{}, errors.New("image name is required")
+ return reference{}, common.Classify(common.ErrBadRequest, errors.New("image name is required"))
}
if inspect, inspectErr := s.dockerService.Call(ctx, func(ctx context.Context, dockerClient *client.Client) (client.ImageInspectResult, error) {
return dockerClient.ImageInspect(ctx, imageName)
}); inspectErr == nil {
imageRef := func() string {
- for _, candidate := range slices.Concat(
- slices.DeleteFunc(slices.Clone(inspect.RepoDigests), func(repoDigest string) bool { return !strings.Contains(repoDigest, "@sha256:") }),
- inspect.RepoTags,
- ) {
- if trimmed := strings.TrimSpace(candidate); trimmed != "" && !strings.Contains(trimmed, "<none>") {
+ for _, candidate := range inspect.RepoDigests {
+ if trimmed := strings.TrimSpace(candidate); strings.Contains(trimmed, "@sha256:") && !strings.Contains(trimmed, "<none>") {
return trimmed
}
}
@@ -226,40 +246,43 @@ func (s *Service) resolveImageAttestationReference(ctx context.Context, imageNam
if strings.HasPrefix(imageName, "sha256:") || (len(imageName) == 64 && !strings.ContainsFunc(imageName, func(r rune) bool {
return (r < '0' || r > '9') && (r < 'a' || r > 'f') && (r < 'A' || r > 'F')
})) {
- return reference{}, fmt.Errorf("image %q does not have a registry reference", imageName)
+ return reference{}, common.Classify(common.ErrNotFound, fmt.Errorf("image %q does not have a registry reference", imageName))
}
if _, err := name.ParseReference(imageName, name.WeakValidation); err != nil {
- return reference{}, fmt.Errorf("image %q does not have a registry reference: %w", imageName, err)
+ return reference{}, common.Classify(common.ErrBadRequest, fmt.Errorf("image %q does not have a registry reference: %w", imageName, err))
}
_, subjectDigest, _ := strings.Cut(imageName, "@")
return reference{
ImageRef: imageName,
SubjectDigest: subjectDigest,
+ External: true,
}, nil
}
-func (s *Service) remoteOptionsForImageRef(ctx context.Context, imageRef string) []remote.Option {
+func (s *Service) remoteOptionsForImageRef(ctx context.Context, resolution reference) ([]remote.Option, error) {
+ imageRef := resolution.ImageRef
options := []remote.Option{remote.WithContext(ctx)}
-
- registryHost, err := registryauth.GetRegistryAddress(imageRef)
- if err != nil {
- slog.DebugContext(ctx, "skipping registry auth for unparsable image ref", "image", imageRef, "error", err)
- return options
+ if resolution.External {
+ safeTransport, err := safeRegistryTransport()
+ if err != nil {
+ return nil, fmt.Errorf("configure safe registry transport: %w", err)
+ }
+ options = append(options, remote.WithTransport(safeTransport))
}
- encodedAuth, err := s.registryAuth(ctx, registryHost)
+ encodedAuth, err := s.registryAuth(ctx, imageRef)
if err != nil {
- slog.DebugContext(ctx, "registry auth lookup failed for attestation request", "image", imageRef, "registry", registryHost, "error", err)
- return options
+ slog.DebugContext(ctx, "registry auth lookup failed for attestation request", "image", imageRef, "error", err)
+ return options, nil
}
if strings.TrimSpace(encodedAuth) == "" {
- return options
+ return options, nil
}
dockerAuth, err := registryauth.DecodeAuthHeader(encodedAuth)
if err != nil {
- slog.DebugContext(ctx, "registry auth decode failed for attestation request", "image", imageRef, "registry", registryHost, "error", err)
- return options
+ slog.DebugContext(ctx, "registry auth decode failed for attestation request", "image", imageRef, "error", err)
+ return options, nil
}
return append(options, remote.WithAuth(authn.FromConfig(authn.AuthConfig{
@@ -268,7 +291,30 @@ func (s *Service) remoteOptionsForImageRef(ctx context.Context, imageRef string)
Auth: dockerAuth.Auth,
IdentityToken: dockerAuth.IdentityToken,
RegistryToken: dockerAuth.RegistryToken,
- })))
+ }))), nil
+}
+
+func classifyRegistryError(ctx context.Context, err error) error {
+ if errors.Is(err, errAttestationLayerTooLarge) {
+ return errAttestationLayerTooLarge
+ }
+ if errors.Is(err, context.Canceled) {
+ return context.Canceled
+ }
+ slog.WarnContext(ctx, "attestation registry request failed", "error", err)
+ transportErr, isTransport := errors.AsType[*transport.Error](err)
+ switch {
+ case errors.Is(err, common.ErrUnsafeRemoteURL):
+ return common.Classify(common.ErrBadRequest, errors.New("registry address is not allowed"))
+ case errors.Is(err, context.DeadlineExceeded):
+ return common.Classify(common.ErrTimeout, errors.New("registry request timed out"))
+ case isTransport && (transportErr.StatusCode == http.StatusUnauthorized || transportErr.StatusCode == http.StatusForbidden):
+ return common.Classify(common.ErrBadRequest, errors.New("registry denied access with the configured credentials"))
+ case isTransport && transportErr.StatusCode == http.StatusNotFound:
+ return common.Classify(common.ErrNotFound, errors.New("image not found in the registry"))
+ default:
+ return common.Classify(common.ErrUnavailable, errors.New("registry unavailable"))
+ }
}
func subjects(descriptor *remote.Descriptor, platform ocispec.Platform, hasPlatform bool) (v1.ImageIndex, []subject, error) {
@@ -340,7 +386,7 @@ func (s *Service) readReferrerAttestations(
(transportErr.StatusCode == http.StatusNotFound || transportErr.StatusCode == http.StatusMethodNotAllowed) {
return nil, nil
}
- return nil, fmt.Errorf("query image referrers for %s: %w", target.Digest, err)
+ return nil, classifyRegistryError(ctx, fmt.Errorf("query image referrers for %s: %w", target.Digest, err))
}
manifest, err := referrers.IndexManifest()
@@ -352,7 +398,11 @@ func (s *Service) readReferrerAttestations(
for _, referrer := range manifest.Manifests {
referrerDescriptor, getErr := remote.Get(repository.Digest(referrer.Digest.String()), remoteOptions...)
if getErr != nil {
- return nil, fmt.Errorf("get image referrer %s: %w", referrer.Digest.String(), getErr)
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return nil, classifyRegistryError(ctx, ctxErr)
+ }
+ slog.WarnContext(ctx, "skipping unreadable image referrer", "subject", target.Digest, "referrer", referrer.Digest.String(), "error", getErr)
+ continue
}
referrerImage, getErr := referrerDescriptor.Image()
@@ -371,7 +421,14 @@ func (s *Service) readReferrerAttestations(
ArtifactType: cmp.Or(referrer.ArtifactType, referrerDescriptor.ArtifactType),
}, target.Platform, query)
if getErr != nil {
- return nil, getErr
+ if errors.Is(getErr, errAttestationLayerTooLarge) {
+ return nil, errAttestationLayerTooLarge
+ }
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return nil, classifyRegistryError(ctx, ctxErr)
+ }
+ slog.WarnContext(ctx, "skipping unreadable image referrer", "subject", target.Digest, "referrer", referrer.Digest.String(), "error", getErr)
+ continue
}
attestations = append(attestations, items...)
}
@@ -400,7 +457,7 @@ func readAttestationImage(ctx context.Context, attestationImage v1.Image, artifa
return nil, fmt.Errorf("read attestation layer %s: %w", layerDescriptor.Digest.String(), layerErr)
}
- rawStatement, layerErr := readAttestationLayerBytes(layer, layerDescriptor.Digest.String())
+ rawStatement, layerErr := readAttestationLayerBytes(ctx, layer, layerDescriptor.Digest.String(), layerDescriptor.Size)
if layerErr != nil {
return nil, layerErr
}
@@ -439,18 +496,25 @@ func readAttestationImage(ctx context.Context, attestationImage v1.Image, artifa
// container is detected from the magic header. gzip and zstd are the algorithms
// supported by the OCI image spec; anything else (including already
// uncompressed JSON) is returned unchanged.
-func readAttestationLayerBytes(layer v1.Layer, digest string) ([]byte, error) {
+func readAttestationLayerBytes(ctx context.Context, layer v1.Layer, digest string, size int64) ([]byte, error) {
+ if size > maxAttestationLayerBytes {
+ return nil, fmt.Errorf("read attestation layer %s: %w", digest, errAttestationLayerTooLarge)
+ }
reader, err := layer.Compressed()
if err != nil {
- return nil, fmt.Errorf("open attestation layer %s: %w", digest, err)
+ return nil, classifyRegistryError(ctx, fmt.Errorf("open attestation layer %s: %w", digest, err))
}
- rawStatement, readErr := io.ReadAll(reader)
+ rawStatement, readErr := io.ReadAll(io.LimitReader(reader, maxAttestationLayerBytes+1))
closeErr := reader.Close()
- if readErr != nil {
- return nil, fmt.Errorf("read attestation layer %s: %w", digest, readErr)
- }
- if closeErr != nil {
- return nil, fmt.Errorf("close attestation layer %s: %w", digest, closeErr)
+ switch {
+ case readErr != nil:
+ return nil, classifyRegistryError(ctx, fmt.Errorf("read attestation layer %s: %w", digest, readErr))
+ case closeErr != nil:
+ return nil, classifyRegistryError(ctx, fmt.Errorf("close attestation layer %s: %w", digest, closeErr))
+ case len(rawStatement) > maxAttestationLayerBytes:
+ return nil, fmt.Errorf("read attestation layer %s: %w", digest, errAttestationLayerTooLarge)
+ case size > 0 && int64(len(rawStatement)) != size:
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("attestation layer %s is %d bytes, descriptor declares %d", digest, len(rawStatement), size))
}
statement, err := func() ([]byte, error) {
@@ -461,19 +525,27 @@ func readAttestationLayerBytes(layer v1.Layer, digest string) ([]byte, error) {
return nil, gzipErr
}
defer func() { _ = gzipReader.Close() }()
- return io.ReadAll(gzipReader)
+ decompressed, gzipErr := io.ReadAll(io.LimitReader(gzipReader, maxAttestationLayerBytes+1))
+ if gzipErr == nil && len(decompressed) > maxAttestationLayerBytes {
+ return nil, errAttestationLayerTooLarge
+ }
+ return decompressed, gzipErr
case len(rawStatement) >= 4 && rawStatement[0] == 0x28 && rawStatement[1] == 0xb5 && rawStatement[2] == 0x2f && rawStatement[3] == 0xfd:
decoder, decoderErr := zstdDecoder()
if decoderErr != nil {
return nil, decoderErr
}
- return decoder.DecodeAll(rawStatement, nil)
+ decompressed, decodeErr := decoder.DecodeAll(rawStatement, nil)
+ if errors.Is(decodeErr, zstd.ErrDecoderSizeExceeded) {
+ return nil, errAttestationLayerTooLarge
+ }
+ return decompressed, decodeErr
default:
return rawStatement, nil
}
}()
if err != nil {
- return nil, fmt.Errorf("decompress attestation layer %s: %w", digest, err)
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("decompress attestation layer %s: %w", digest, err))
}
return statement, nil
}
diff --git a/backend/internal/image/children/attestations/service_test.go b/backend/internal/image/children/attestations/service_test.go
index 3cf2281b5..1a8d0cfe3 100644
--- a/backend/internal/image/children/attestations/service_test.go
+++ b/backend/internal/image/children/attestations/service_test.go
@@ -8,6 +8,8 @@ import (
"github.com/google/go-containerregistry/pkg/v1/static"
"github.com/klauspost/compress/zstd"
"github.com/stretchr/testify/require"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
)
func TestReadAttestationLayerBytesDecompressesGzip(t *testing.T) {
@@ -28,7 +30,7 @@ func TestReadAttestationLayerBytesDecompressesGzip(t *testing.T) {
}
layer := static.NewLayer(buf.Bytes(), inTotoLayerMediaType)
- got, err := readAttestationLayerBytes(layer, "sha256:test")
+ got, err := readAttestationLayerBytes(t.Context(), layer, "sha256:test", int64(buf.Len()))
require.NoError(t, err,
"unexpected error: %v", err)
@@ -41,7 +43,7 @@ func TestReadAttestationLayerBytesPassesThroughRawJSON(t *testing.T) {
statement := []byte(`{"predicateType":"https://spdx.dev/Document"}`)
layer := static.NewLayer(statement, inTotoLayerMediaType)
- got, err := readAttestationLayerBytes(layer, "sha256:test")
+ got, err := readAttestationLayerBytes(t.Context(), layer, "sha256:test", int64(len(statement)))
require.NoError(t, err,
"unexpected error: %v", err)
@@ -66,7 +68,7 @@ func TestReadAttestationLayerBytesDecompressesZstd(t *testing.T) {
}
layer := static.NewLayer(compressed, inTotoLayerMediaType)
- got, err := readAttestationLayerBytes(layer, "sha256:test")
+ got, err := readAttestationLayerBytes(t.Context(), layer, "sha256:test", int64(len(compressed)))
require.NoError(t, err,
"unexpected error: %v", err)
@@ -74,3 +76,34 @@ func TestReadAttestationLayerBytesDecompressesZstd(t *testing.T) {
require.True(t, bytes.Equal(got, statement),
"expected decompressed statement %q, got %q", statement, got)
}
+
+func TestReadAttestationLayerBytesRejectsOversizedDecompression(t *testing.T) {
+ oversized := make([]byte, maxAttestationLayerBytes+1)
+
+ var gzipped bytes.Buffer
+ gz := gzip.NewWriter(&gzipped)
+ _, err := gz.Write(oversized)
+ require.NoError(t, err)
+ require.NoError(t, gz.Close())
+
+ encoder, err := zstd.NewWriter(nil)
+ require.NoError(t, err)
+ zstdCompressed := encoder.EncodeAll(oversized, nil)
+ require.NoError(t, encoder.Close())
+
+ for _, compressed := range [][]byte{gzipped.Bytes(), zstdCompressed} {
+ layer := static.NewLayer(compressed, inTotoLayerMediaType)
+ _, readErr := readAttestationLayerBytes(t.Context(), layer, "sha256:test", int64(len(compressed)))
+ require.ErrorIs(t, readErr, errAttestationLayerTooLarge)
+ }
+}
+
+func TestReadAttestationLayerBytesRejectsSizeMismatch(t *testing.T) {
+ statement := []byte(`{"predicateType":"https://spdx.dev/Document"}`)
+
+ _, err := readAttestationLayerBytes(t.Context(), static.NewLayer(statement, inTotoLayerMediaType), "sha256:test", int64(len(statement)+1))
+ require.ErrorIs(t, err, common.ErrBadRequest)
+
+ _, err = readAttestationLayerBytes(t.Context(), static.NewLayer(statement, inTotoLayerMediaType), "sha256:test", maxAttestationLayerBytes+1)
+ require.ErrorIs(t, err, errAttestationLayerTooLarge)
+}
diff --git a/backend/internal/image/children/patch/service_test.go b/backend/internal/image/children/patch/service_test.go
index e1c137578..8d4c20cdd 100644
--- a/backend/internal/image/children/patch/service_test.go
+++ b/backend/internal/image/children/patch/service_test.go
@@ -122,7 +122,7 @@ func patchFeatureSettings(t *testing.T) (*settings.SettingsService, *database.DB
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &vulnerability.VulnerabilityScanRecord{}, &vulnerability.VulnerabilityReportRecord{}, &ImagePatchRecord{}))
db := &database.DB{DB: gdb}
- svc, err := settings.NewSettingsService(t.Context(), db)
+ svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/image/handler.go b/backend/internal/image/handler.go
index 629539934..f914a5ba2 100644
--- a/backend/internal/image/handler.go
+++ b/backend/internal/image/handler.go
@@ -6,9 +6,11 @@ import (
"errors"
"fmt"
"io"
+ "log/slog"
"net/http"
"strings"
+ "github.com/containerd/errdefs"
"github.com/danielgtaylor/huma/v2"
activitytypes "github.com/getarcaneapp/arcane/types/v2/activity"
"github.com/getarcaneapp/arcane/types/v2/base"
@@ -22,6 +24,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
"github.com/getarcaneapp/arcane/backend/v2/internal/build"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"
@@ -180,7 +183,10 @@ func (h *ImageHandler) ListImages(ctx context.Context, input *ListImagesInput) (
func (h *ImageHandler) GetImage(ctx context.Context, input *GetImageInput) (*handlerutil.Out[image.DetailSummary], error) {
out, err := h.imageService.GetImageDetail(ctx, input.ImageID)
if err != nil {
- return nil, huma.Error404NotFound("Image not found: " + err.Error())
+ if errdefs.IsNotFound(err) {
+ return nil, huma.Error404NotFound("Image not found: " + err.Error())
+ }
+ return nil, huma.Error500InternalServerError("Failed to get image: " + err.Error())
}
return &handlerutil.Out[image.DetailSummary]{
@@ -279,7 +285,9 @@ func (h *ImageHandler) ExportImage(ctx context.Context, input *ExportImageInput)
cmp.Or(strings.Trim(strings.NewReplacer("/", "_", ":", "_", "@", "_").Replace(imageName), "._-"), "image")+".tar",
))
- _, _ = io.Copy(humaCtx.BodyWriter(), reader)
+ if _, copyErr := io.Copy(humaCtx.BodyWriter(), reader); copyErr != nil {
+ slog.WarnContext(humaCtx.Context(), "image export stream interrupted", "image", imageName, "error", copyErr)
+ }
},
}, nil
}
@@ -300,7 +308,14 @@ func (h *ImageHandler) RemoveImage(ctx context.Context, input *RemoveImageInput)
}
if removeImageErr := h.imageService.RemoveImage(ctx, input.ImageID, input.Force, *user); removeImageErr != nil {
- return nil, huma.Error500InternalServerError("Failed to remove image: " + removeImageErr.Error())
+ switch {
+ case errdefs.IsConflict(removeImageErr):
+ return nil, huma.Error409Conflict("Failed to remove image: " + removeImageErr.Error())
+ case errdefs.IsNotFound(removeImageErr):
+ return nil, huma.Error404NotFound("Failed to remove image: " + removeImageErr.Error())
+ default:
+ return nil, huma.Error500InternalServerError("Failed to remove image: " + removeImageErr.Error())
+ }
}
return handlerutil.MessageOutput("Image removed successfully", ""), nil
@@ -348,7 +363,12 @@ func (h *ImageHandler) PullImage(ctx context.Context, input *PullImageInput) (*h
activitylib.AwaitHandlerActivitySlot(runtimeCtx, h.activityService, activityID, input.EnvironmentID)
writer := activitylib.NewWriter(runtimeCtx, h.activityService, activityID, rawWriter, "Pulling image")
- if pullImageErr := h.imageService.PullImage(runtimeCtx, fullImageName, writer, *user, credentials); pullImageErr != nil {
+ if pullImageErr := h.imageService.Pull(runtimeCtx, PullRequest{
+ Ref: fullImageName,
+ Progress: writer,
+ User: *user,
+ Credentials: credentials,
+ }); pullImageErr != nil {
activitylib.FlushWriter(writer)
activitylib.CompleteHandlerActivity(runtimeCtx, h.activityService, activityID, "Image pull failed", pullImageErr)
activitylib.WriteErrorLine(rawWriter, pullImageErr)
@@ -558,6 +578,9 @@ func (h *ImageHandler) UploadImage(ctx context.Context, input *UploadImageInput)
result, err := h.imageService.LoadImageFromReader(ctx, file, session.Filename, *user, int64(h.settingsService.GetIntSetting(ctx, "maxImageUploadSize", 500))*1024*1024)
if err != nil {
+ if errors.Is(err, common.ErrBadRequest) {
+ return nil, huma.Error413RequestEntityTooLarge("Failed to load image: " + err.Error())
+ }
return nil, huma.Error500InternalServerError("Failed to load image: " + err.Error())
}
diff --git a/backend/internal/image/module.go b/backend/internal/image/module.go
index 5ea746a5b..00e84748b 100644
--- a/backend/internal/image/module.go
+++ b/backend/internal/image/module.go
@@ -49,7 +49,7 @@ func New(
build: buildService,
activity: activityService,
upload: uploadService,
- attestationsHandler: attestations.NewHandler(attestations.NewService(service.dockerService, service.registryService.GetRegistryAuthForHost)),
+ attestationsHandler: attestations.NewHandler(attestations.NewService(service.dockerService, service.registryService.GetRegistryAuthForImage)),
}
}
diff --git a/backend/internal/image/service.go b/backend/internal/image/service.go
index f171ec945..857430472 100644
--- a/backend/internal/image/service.go
+++ b/backend/internal/image/service.go
@@ -11,8 +11,10 @@ import (
"net/url"
"slices"
"strings"
+ "sync/atomic"
"time"
+ "github.com/containerd/errdefs"
"github.com/distribution/reference"
"github.com/getarcaneapp/arcane/types/v2"
activitytypes "github.com/getarcaneapp/arcane/types/v2/activity"
@@ -360,6 +362,9 @@ func (s *ImageService) cleanupRemovedImages(ctx context.Context, deleted []image
if deleteErr := s.vulnerabilityService.DeleteScanResultsByImageIDs(ctx, idsToDelete); deleteErr != nil {
slog.WarnContext(ctx, "failed to delete vulnerability scan records", "count", len(idsToDelete), "error", deleteErr)
}
+ if _, orphanErr := s.vulnerabilityService.CleanupOrphanedScanRecords(ctx); orphanErr != nil {
+ slog.WarnContext(ctx, "failed to clean up orphaned vulnerability scan records", "error", orphanErr)
+ }
}
func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user usertypes.Actor, externalCreds []containerregistry.Credential) error {
@@ -617,8 +622,7 @@ func (s *ImageService) ExportImage(ctx context.Context, imageName string) (io.Re
}
func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader, fileName string, user usertypes.Actor, maxSizeBytes int64) (*imagetypes.LoadResult, error) {
- // Wrap reader with size limit enforcement
- limitedReader := io.LimitReader(reader, maxSizeBytes+1)
+ limitedReader := &uploadLimitReader{reader: reader, remaining: maxSizeBytes + 1}
dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
@@ -629,9 +633,8 @@ func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader
// ImageLoad accepts a tar archive reader and optional load options
loadResp, err := dockerClient.ImageLoad(ctx, limitedReader)
if err != nil {
- // Check if error is due to size limit being exceeded
- if err.Error() == "unexpected EOF" || strings.Contains(err.Error(), "unexpected EOF") {
- return nil, fmt.Errorf("file size exceeds maximum allowed size of %d MB", maxSizeBytes/(1024*1024))
+ if limitedReader.exceeded.Load() {
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("file size exceeds maximum allowed size of %d MB", maxSizeBytes/(1024*1024)))
}
s.eventService.LogErrorEvent(ctx, event.EventTypeImageError, "image", "", fileName, user.ID, user.Username, "0", err, database.JSON{"action": "load", "file": fileName})
return nil, fmt.Errorf("failed to load image from tar: %w", err)
@@ -640,6 +643,9 @@ func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader
var responseBuilder strings.Builder
streamErr := docker.RenderJSONMessageStream(loadResp, &responseBuilder)
+ if streamErr != nil && limitedReader.exceeded.Load() {
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("file size exceeds maximum allowed size of %d MB", maxSizeBytes/(1024*1024)))
+ }
if streamErr != nil {
s.eventService.LogErrorEvent(
ctx,
@@ -670,6 +676,28 @@ func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader
return &imagetypes.LoadResult{Stream: responseBuilder.String()}, nil
}
+var errImageUploadTooLarge = errors.New("image upload exceeds the size limit")
+
+type uploadLimitReader struct {
+ reader io.Reader
+ remaining int64
+ exceeded atomic.Bool
+}
+
+func (r *uploadLimitReader) Read(p []byte) (int, error) {
+ if r.remaining <= 0 {
+ r.exceeded.Store(true)
+ return 0, errImageUploadTooLarge
+ }
+ n, err := r.reader.Read(p[:min(int64(len(p)), r.remaining)])
+ r.remaining -= int64(n)
+ if r.remaining <= 0 {
+ r.exceeded.Store(true)
+ return n, errImageUploadTooLarge
+ }
+ return n, err
+}
+
func (s *ImageService) ImageExistsLocally(ctx context.Context, imageName string) (bool, error) {
_, err := s.dockerService.Call(ctx, func(ctx context.Context, dockerClient *client.Client) (client.ImageInspectResult, error) {
return dockerClient.ImageInspect(ctx, imageName)
@@ -678,8 +706,7 @@ func (s *ImageService) ImageExistsLocally(ctx context.Context, imageName string)
return true, nil
}
- errLower := strings.ToLower(err.Error())
- if strings.Contains(errLower, "no such image") || strings.Contains(errLower, "not found") {
+ if errdefs.IsNotFound(err) {
return false, nil
}
return false, fmt.Errorf("failed to inspect image %s: %w", imageName, err)
@@ -705,7 +732,7 @@ func (s *ImageService) PullOptionsWithAuth(ctx context.Context, imageRef string,
}
}
- authStr, err := s.registryService.GetRegistryAuthForHost(ctx, registryHost)
+ authStr, err := s.registryService.GetRegistryAuthForImage(ctx, imageRef)
if err != nil {
return client.ImagePullOptions{}, fmt.Errorf("failed to get registry credentials: %w", err)
}
diff --git a/backend/internal/imageupdate/service_test.go b/backend/internal/imageupdate/service_test.go
index 4fab8f430..c81dc4a04 100644
--- a/backend/internal/imageupdate/service_test.go
+++ b/backend/internal/imageupdate/service_test.go
@@ -35,6 +35,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
@@ -140,9 +141,9 @@ func createImageUpdateTestPullRegistry(t *testing.T, db *database.DB, localUrl,
func decodeImageUpdateRegistryAuth(t *testing.T, encoded string) dockerregistry.AuthConfig {
t.Helper()
- config, err := authconfig.Decode(encoded)
+ authConfig, err := authconfig.Decode(encoded)
require.NoError(t, err)
- return *config
+ return *authConfig
}
// TestParseImageReference tests the parseImageReference function with various image formats
@@ -2225,7 +2226,7 @@ func newImageUpdateTestSettingsService(t *testing.T, registryTimeout, dockerAPIT
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&settings.SettingVariable{}))
dbWrap := &database.DB{DB: db}
- service, err := settings.NewSettingsService(ctx, dbWrap)
+ service, err := settings.NewSettingsService(ctx, dbWrap, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, service.Stop(context.WithoutCancel(t.Context()))) })
}
@@ -3131,7 +3132,7 @@ func TestImageUpdateService_RunImageCheckExhaustedRateLimitKeepsPreviousResult(t
require.NoError(t, err)
require.Len(t, outcome.Targets, 1)
require.Contains(t, outcome.Targets[0].Message, "toomanyrequests")
- require.Equal(t, int32(5*imageCheckAttempts), calls.Load(), "each workflow attempt spends the registry's own retry budget")
+ require.Equal(t, int32(imageCheckAttempts), calls.Load(), "a rate-limited registry lookup is not retried within a workflow attempt")
var saved ImageUpdateRecord
require.NoError(t, db.First(&saved, "id = ?", "sha256:app").Error)
diff --git a/backend/internal/job/service_test.go b/backend/internal/job/service_test.go
index 3fb263935..ecb2c7835 100644
--- a/backend/internal/job/service_test.go
+++ b/backend/internal/job/service_test.go
@@ -64,7 +64,7 @@ func setupSettingsTestDB(t *testing.T) *database.DB {
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- service, err := settings.NewSettingsService(ctx, db)
+ service, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() {
stopCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)
diff --git a/backend/internal/notification/service.go b/backend/internal/notification/service.go
index 9b67bbf62..865e484a2 100644
--- a/backend/internal/notification/service.go
+++ b/backend/internal/notification/service.go
@@ -183,7 +183,7 @@ func (s *NotificationService) dispatchNotificationToManager(ctx context.Context,
if publishViaTunnelErr := publishViaTunnel(); publishViaTunnelErr != nil {
return notification.DispatchResponse{}, fmt.Errorf("notification dispatch needs either MANAGER_API_URL + AGENT_TOKEN or a connected edge tunnel: %w", publishViaTunnelErr)
}
- return notification.DispatchResponse{Message: "notification dispatched via edge tunnel"}, nil
+ return notification.DispatchResponse{Message: "notification dispatched via edge tunnel", Delivered: 1}, nil
}
dispatchURL := strings.TrimRight(httpx.ManagerBaseURL(s.config.ManagerApiUrl), "/") + "/api/notifications/dispatch"
@@ -198,7 +198,7 @@ func (s *NotificationService) dispatchNotificationToManager(ctx context.Context,
if err != nil {
// An agent configured for HTTP may still hold a healthy edge tunnel, so try it before giving up.
if tunnelErr := publishViaTunnel(); tunnelErr == nil {
- return notification.DispatchResponse{Message: "notification dispatched via edge tunnel"}, nil
+ return notification.DispatchResponse{Message: "notification dispatched via edge tunnel", Delivered: 1}, nil
}
return notification.DispatchResponse{}, fmt.Errorf("failed to dispatch notification to manager: %w", err)
}
@@ -214,11 +214,7 @@ func (s *NotificationService) dispatchNotificationToManager(ctx context.Context,
return apiResponse.Data, nil
}
- // A non-2xx (stale token, wrong URL, proxy) can fail independently of the tunnel, so fall back here too.
- responseBody, _ := io.ReadAll(resp.Body)
- if tunnelErr := publishViaTunnel(); tunnelErr == nil {
- return notification.DispatchResponse{Message: "notification dispatched via edge tunnel"}, nil
- }
+ responseBody, _ := io.ReadAll(io.LimitReader(resp.Body, 8*1024))
return notification.DispatchResponse{}, fmt.Errorf("manager notification dispatch failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(responseBody)))
}
@@ -260,34 +256,48 @@ func (s *NotificationService) DispatchNotificationForEnvironment(ctx context.Con
}
func (s *NotificationService) dispatchForTarget(ctx context.Context, target NotificationTarget, payload notification.DispatchRequest) (notification.DispatchResponse, error) {
- var err error
- dispatchResponse := notification.DispatchResponse{Message: "Notification dispatched successfully"}
+ delivered, err := s.deliverForTarget(ctx, target, payload)
+ if err != nil && delivered == 0 {
+ return notification.DispatchResponse{}, err
+ }
+ if err != nil {
+ slog.WarnContext(ctx, "Notification dispatch partially failed", "kind", payload.Kind, "delivered", delivered, "error", err)
+ return notification.DispatchResponse{
+ Message: "Notification dispatched with errors: " + err.Error(),
+ Delivered: delivered,
+ }, nil
+ }
+ return notification.DispatchResponse{
+ Message: "Notification dispatched successfully",
+ Delivered: delivered,
+ }, nil
+}
+
+func (s *NotificationService) deliverForTarget(ctx context.Context, target NotificationTarget, payload notification.DispatchRequest) (int, error) {
switch payload.Kind {
case notification.DispatchKindImageUpdate:
if payload.ImageUpdate == nil {
- return notification.DispatchResponse{}, errors.New("image update payload is required")
+ return 0, errors.New("image update payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
imageUpdate := payload.ImageUpdate
- dispatchResponse.Delivered, err = s.sendImageUpdateNotificationForTarget(ctx, target, imageUpdate.ImageRef, &imageUpdate.UpdateInfo, notifications.NotificationEventImageUpdate)
- return dispatchResponse, err
+ return s.sendImageUpdateNotificationForTarget(ctx, target, imageUpdate.ImageRef, &imageUpdate.UpdateInfo, notifications.NotificationEventImageUpdate)
case notification.DispatchKindBatchImageUpdate:
if payload.BatchImageUpdate == nil {
- return notification.DispatchResponse{}, errors.New("batch image update payload is required")
+ return 0, errors.New("batch image update payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
- dispatchResponse.Delivered, err = s.sendBatchImageUpdateNotificationForTarget(ctx, target, payload.BatchImageUpdate.Updates)
- return dispatchResponse, err
+ return s.sendBatchImageUpdateNotificationForTarget(ctx, target, payload.BatchImageUpdate.Updates)
case notification.DispatchKindContainerUpdate:
if payload.ContainerUpdate == nil {
- return notification.DispatchResponse{}, errors.New("container update payload is required")
+ return 0, errors.New("container update payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
update := payload.ContainerUpdate
- return dispatchResponse, s.sendContainerUpdateNotificationForTarget(ctx, target, update.ContainerName, update.ImageRef, update.OldDigest, update.NewDigest)
+ return s.sendContainerUpdateNotificationForTarget(ctx, target, update.ContainerName, update.ImageRef, update.OldDigest, update.NewDigest)
case notification.DispatchKindBatchContainerUpdate:
if payload.BatchContainerUpdate == nil {
- return notification.DispatchResponse{}, errors.New("batch container update payload is required")
+ return 0, errors.New("batch container update payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
entries := make([]notifications.ContainerUpdateBatchEntry, 0, len(payload.BatchContainerUpdate.Updates))
@@ -299,27 +309,27 @@ func (s *NotificationService) dispatchForTarget(ctx context.Context, target Noti
NewDigest: update.NewDigest,
})
}
- return dispatchResponse, s.sendBatchContainerUpdateNotificationForTarget(ctx, target, entries)
+ return s.sendBatchContainerUpdateNotificationForTarget(ctx, target, entries)
case notification.DispatchKindVulnerabilityFound:
if payload.VulnerabilityFound == nil {
- return notification.DispatchResponse{}, errors.New("vulnerability payload is required")
+ return 0, errors.New("vulnerability payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
- return dispatchResponse, s.sendVulnerabilityNotificationForTarget(ctx, target, VulnerabilityNotificationPayload(*payload.VulnerabilityFound))
+ return s.sendVulnerabilityNotificationForTarget(ctx, target, VulnerabilityNotificationPayload(*payload.VulnerabilityFound))
case notification.DispatchKindPruneReport:
if payload.PruneReport == nil {
- return notification.DispatchResponse{}, errors.New("prune report payload is required")
+ return 0, errors.New("prune report payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
- return dispatchResponse, s.sendPruneReportNotificationForTarget(ctx, target, &payload.PruneReport.Result)
+ return s.sendPruneReportNotificationForTarget(ctx, target, &payload.PruneReport.Result)
case notification.DispatchKindAutoHeal:
if payload.AutoHeal == nil {
- return notification.DispatchResponse{}, errors.New("auto-heal payload is required")
+ return 0, errors.New("auto-heal payload is required")
}
logManagerDispatchNotification(ctx, target, payload.Kind)
- return dispatchResponse, s.sendAutoHealNotificationForTarget(ctx, target, payload.AutoHeal.ContainerName, payload.AutoHeal.ContainerID)
+ return s.sendAutoHealNotificationForTarget(ctx, target, payload.AutoHeal.ContainerName, payload.AutoHeal.ContainerID)
default:
- return notification.DispatchResponse{}, fmt.Errorf("%s: %w", payload.Kind, ErrUnsupportedDispatchKind)
+ return 0, fmt.Errorf("%s: %w", payload.Kind, ErrUnsupportedDispatchKind)
}
}
@@ -692,10 +702,11 @@ func (s *NotificationService) SendBatchContainerUpdateNotification(ctx context.C
return err
}
- return s.sendBatchContainerUpdateNotificationForTarget(ctx, target, entries)
+ _, err = s.sendBatchContainerUpdateNotificationForTarget(ctx, target, entries)
+ return err
}
-func (s *NotificationService) sendBatchContainerUpdateNotificationForTarget(ctx context.Context, target NotificationTarget, entries []notifications.ContainerUpdateBatchEntry) error {
+func (s *NotificationService) sendBatchContainerUpdateNotificationForTarget(ctx context.Context, target NotificationTarget, entries []notifications.ContainerUpdateBatchEntry) (int, error) {
containerNames := make([]string, 0, len(entries))
for _, entry := range entries {
containerNames = append(containerNames, entry.ContainerName)
@@ -710,8 +721,7 @@ func (s *NotificationService) sendBatchContainerUpdateNotificationForTarget(ctx
content := s.templates.BatchContainerUpdate(target.EnvironmentName, entries)
content.Vars = notifications.EventVars(target.EnvironmentName, target.EnvironmentID, notifications.NotificationEventContainerUpdate)
logRef := strings.Join(containerNames, ", ")
- _, err := s.notifyEnabledProviders(ctx, target, notifications.NotificationEventContainerUpdate, logRef, metadata, content)
- return err
+ return s.notifyEnabledProviders(ctx, target, notifications.NotificationEventContainerUpdate, logRef, metadata, content)
}
// SendImageUpdateNotification returns how many providers the notification was delivered to.
@@ -781,10 +791,11 @@ func (s *NotificationService) SendContainerUpdateNotification(ctx context.Contex
return err
}
- return s.sendContainerUpdateNotificationForTarget(ctx, target, containerName, imageRef, oldDigest, newDigest)
+ _, err = s.sendContainerUpdateNotificationForTarget(ctx, target, containerName, imageRef, oldDigest, newDigest)
+ return err
}
-func (s *NotificationService) sendContainerUpdateNotificationForTarget(ctx context.Context, target NotificationTarget, containerName, imageRef, oldDigest, newDigest string) error {
+func (s *NotificationService) sendContainerUpdateNotificationForTarget(ctx context.Context, target NotificationTarget, containerName, imageRef, oldDigest, newDigest string) (int, error) {
metadata := database.JSON{
"containerName": containerName,
"oldDigest": oldDigest,
@@ -793,8 +804,7 @@ func (s *NotificationService) sendContainerUpdateNotificationForTarget(ctx conte
}
content := s.templates.ContainerUpdate(target.EnvironmentName, containerName, imageRef, oldDigest, newDigest)
content.Vars = notifications.EventVars(target.EnvironmentName, target.EnvironmentID, notifications.NotificationEventContainerUpdate)
- _, err := s.notifyEnabledProviders(ctx, target, notifications.NotificationEventContainerUpdate, imageRef, metadata, content)
- return err
+ return s.notifyEnabledProviders(ctx, target, notifications.NotificationEventContainerUpdate, imageRef, metadata, content)
}
// SendVulnerabilityNotification notifies providers subscribed to vulnerability_found events.
@@ -826,10 +836,11 @@ func (s *NotificationService) SendVulnerabilityNotification(ctx context.Context,
return err
}
- return s.sendVulnerabilityNotificationForTarget(ctx, target, payload)
+ _, err = s.sendVulnerabilityNotificationForTarget(ctx, target, payload)
+ return err
}
-func (s *NotificationService) sendVulnerabilityNotificationForTarget(ctx context.Context, target NotificationTarget, payload VulnerabilityNotificationPayload) error {
+func (s *NotificationService) sendVulnerabilityNotificationForTarget(ctx context.Context, target NotificationTarget, payload VulnerabilityNotificationPayload) (int, error) {
metadata := database.JSON{
"cveId": payload.CVEID,
"severity": payload.Severity,
@@ -838,8 +849,7 @@ func (s *NotificationService) sendVulnerabilityNotificationForTarget(ctx context
}
content := s.templates.Vulnerability(target.EnvironmentName, notification.DispatchVulnerabilityFound(payload))
content.Vars = notifications.EventVars(target.EnvironmentName, target.EnvironmentID, notifications.NotificationEventVulnerabilityFound)
- _, err := s.notifyEnabledProviders(ctx, target, notifications.NotificationEventVulnerabilityFound, payload.ImageName, metadata, content)
- return err
+ return s.notifyEnabledProviders(ctx, target, notifications.NotificationEventVulnerabilityFound, payload.ImageName, metadata, content)
}
// SendBatchImageUpdateNotification returns how many providers the notification was delivered to.
@@ -930,18 +940,18 @@ func (s *NotificationService) SendPruneReportNotification(ctx context.Context, r
return err
}
- return s.sendPruneReportNotificationForTarget(ctx, target, result)
+ _, err = s.sendPruneReportNotificationForTarget(ctx, target, result)
+ return err
}
-func (s *NotificationService) sendPruneReportNotificationForTarget(ctx context.Context, target NotificationTarget, result *system.PruneAllResult) error {
+func (s *NotificationService) sendPruneReportNotificationForTarget(ctx context.Context, target NotificationTarget, result *system.PruneAllResult) (int, error) {
metadata := database.JSON{
"spaceReclaimed": result.SpaceReclaimed,
"eventType": string(notifications.NotificationEventPruneReport),
}
content := s.templates.PruneReport(target.EnvironmentName, result)
content.Vars = notifications.EventVars(target.EnvironmentName, target.EnvironmentID, notifications.NotificationEventPruneReport)
- _, err := s.notifyEnabledProviders(ctx, target, notifications.NotificationEventPruneReport, "System Prune Report", metadata, content)
- return err
+ return s.notifyEnabledProviders(ctx, target, notifications.NotificationEventPruneReport, "System Prune Report", metadata, content)
}
// SendAutoHealNotification sends a notification when a container is auto-healed.
@@ -962,18 +972,18 @@ func (s *NotificationService) SendAutoHealNotification(ctx context.Context, cont
return err
}
- return s.sendAutoHealNotificationForTarget(ctx, target, containerName, containerID)
+ _, err = s.sendAutoHealNotificationForTarget(ctx, target, containerName, containerID)
+ return err
}
-func (s *NotificationService) sendAutoHealNotificationForTarget(ctx context.Context, target NotificationTarget, containerName, containerID string) error {
+func (s *NotificationService) sendAutoHealNotificationForTarget(ctx context.Context, target NotificationTarget, containerName, containerID string) (int, error) {
metadata := database.JSON{
"containerID": containerID,
"eventType": string(notifications.NotificationEventAutoHeal),
}
content := s.templates.AutoHeal(target.EnvironmentName, containerName)
content.Vars = notifications.EventVars(target.EnvironmentName, target.EnvironmentID, notifications.NotificationEventAutoHeal)
- _, err := s.notifyEnabledProviders(ctx, target, notifications.NotificationEventAutoHeal, containerName, metadata, content)
- return err
+ return s.notifyEnabledProviders(ctx, target, notifications.NotificationEventAutoHeal, containerName, metadata, content)
}
// --- Test notifications ---
diff --git a/backend/internal/oidc/service_test.go b/backend/internal/oidc/service_test.go
index 8289428c4..95e6e374d 100644
--- a/backend/internal/oidc/service_test.go
+++ b/backend/internal/oidc/service_test.go
@@ -110,7 +110,7 @@ func setupSettingsTestDB(t *testing.T) *database.DB {
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.go
index 79b3250f8..92edc564b 100644
--- a/backend/internal/project/service_test.go
+++ b/backend/internal/project/service_test.go
@@ -142,7 +142,7 @@ func TestValidateWorkspaceChangesAgainstGitOps(t *testing.T) {
func newSettingsServiceForTest(t *testing.T, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
@@ -10142,7 +10142,7 @@ func setupLifecycleTestDB(t *testing.T) *database.DB {
func newLifecycleTestService(t *testing.T, db *database.DB) (*LifecycleService, *settings.SettingsService) {
t.Helper()
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
events := event.NewEventService(db, nil, nil)
diff --git a/backend/internal/registry/children/browse/service.go b/backend/internal/registry/children/browse/service.go
index a398a4afd..d322623b0 100644
--- a/backend/internal/registry/children/browse/service.go
+++ b/backend/internal/registry/children/browse/service.go
@@ -18,6 +18,7 @@ import (
"github.com/google/go-containerregistry/pkg/v1"
"github.com/google/go-containerregistry/pkg/v1/remote"
"github.com/google/go-containerregistry/pkg/v1/remote/transport"
+ "github.com/samber/hot"
"go.getarcane.app/kit/pkg"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
@@ -30,13 +31,18 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/tracing"
)
-const tagDetailsConcurrency = 4
+const (
+ tagDetailsConcurrency = 4
+ maxBrowsePageSize = 100
+ browseListCacheTTL = 30 * time.Second
+)
// Service browses repositories and tags through the distribution API.
type Service struct {
resolve func(ctx context.Context, id string) (containerregistry.ContainerRegistry, *containerregistry.Credential, error)
lookupContext func(ctx context.Context) (context.Context, context.CancelFunc)
transport http.RoundTripper
+ names *hot.HotCache[string, []string]
}
// target is a configured registry resolved for the distribution API.
@@ -46,6 +52,7 @@ type target struct {
prefix string
nameOptions []name.Option
options []remote.Option
+ cacheKey string
}
func NewService(
@@ -53,7 +60,24 @@ func NewService(
lookupContext func(ctx context.Context) (context.Context, context.CancelFunc),
roundTripper http.RoundTripper,
) *Service {
- return &Service{resolve: resolve, lookupContext: lookupContext, transport: roundTripper}
+ return &Service{
+ resolve: resolve,
+ lookupContext: lookupContext,
+ transport: roundTripper,
+ names: hot.NewHotCache[string, []string](hot.LRU, 256).WithTTL(browseListCacheTTL).Build(),
+ }
+}
+
+func (s *Service) cachedNames(key string, list func() ([]string, error)) ([]string, error) {
+ if cached, found, _ := s.names.Get(key); found {
+ return slices.Clone(cached), nil
+ }
+ names, err := list()
+ if err != nil {
+ return nil, err
+ }
+ s.names.Set(key, slices.Clone(names))
+ return names, nil
}
// ListRepositories lists the repositories of a configured registry through the
@@ -73,7 +97,9 @@ func (s *Service) ListRepositories(ctx context.Context, id string, params pagina
return nil, pagination.Response{}, err
}
- names, err := remote.Catalog(lookupCtx, target.registry, target.options...)
+ names, err := s.cachedNames(target.cacheKey, func() ([]string, error) {
+ return remote.Catalog(lookupCtx, target.registry, target.options...)
+ })
if err != nil {
return nil, pagination.Response{}, classifyBrowseError(err, "failed to list repositories (the registry may not support the catalog API)")
}
@@ -111,7 +137,9 @@ func (s *Service) ListRepositoryTags(ctx context.Context, id, repository string,
return nil, pagination.Response{}, err
}
- names, err := remote.List(repo, target.options...)
+ names, err := s.cachedNames(target.cacheKey+"\x00"+repository, func() ([]string, error) {
+ return remote.List(repo, target.options...)
+ })
if err != nil {
return nil, pagination.Response{}, classifyBrowseError(err, "failed to list tags")
}
@@ -167,6 +195,7 @@ func (s *Service) DeleteRepositoryTag(ctx context.Context, id, repository, tag s
if deleteErr := remote.Delete(repo.Digest(descriptor.Digest.String()), target.options...); deleteErr != nil {
return "", classifyBrowseError(deleteErr, "failed to delete manifest")
}
+ s.names.Delete(target.cacheKey + "\x00" + repository)
return descriptor.Digest.String(), nil
}
@@ -187,6 +216,7 @@ func (s *Service) target(ctx context.Context, id string) (*target, error) {
return &target{
registry: registryName,
prefix: prefix,
+ cacheKey: fmt.Sprintf("%s\x00%s\x00%s\x00%t", id, reg.URL, reg.Username, reg.Insecure),
nameOptions: kit.Ternary(reg.Insecure, []name.Option{name.StrictValidation, name.Insecure}, []name.Option{name.StrictValidation}),
options: append([]remote.Option{
remote.WithContext(ctx),
@@ -379,7 +409,17 @@ func tagDetails(repo name.Repository, options []remote.Option, tagName string) c
return tag(platforms, nil, nil)
}
-func paginateNames(names []string, params pagination.QueryParams) ([]string, pagination.Response) {
+func paginateNames(names []string, requested pagination.QueryParams) ([]string, pagination.Response) {
+ params := pagination.QueryParams{
+ SearchQuery: requested.SearchQuery,
+ SortParams: requested.SortParams,
+ Params: pagination.Params{
+ Start: requested.Start,
+ Limit: kit.Ternary(requested.Limit <= 0 || requested.Limit > maxBrowsePageSize, maxBrowsePageSize, requested.Limit),
+ SkipCount: requested.SkipCount,
+ },
+ Filters: requested.Filters,
+ }
result := pagination.Config[string]{
SearchAccessors: []pagination.SearchAccessor[string]{
func(item string) (string, error) { return item, nil },
diff --git a/backend/internal/registry/service.go b/backend/internal/registry/service.go
index 13eca7ce3..2ca0572da 100644
--- a/backend/internal/registry/service.go
+++ b/backend/internal/registry/service.go
@@ -60,13 +60,14 @@ import (
const (
registryCacheTTL = 30 * time.Minute
+ registryDigestFailureTTL = time.Minute
RegistryTypeGeneric string = "generic"
RegistryTypeECR string = "ecr"
registryPullCountKeyPrefix = "container_registry:pulls:"
registryRateLimitKeyPrefix = "container_registry:rate_limits:"
dockerHubRateLimitRepository = "ratelimitpreview/test"
dockerHubRateLimitTag = "latest"
- ecrTokenTTL = 12 * time.Hour
+ ecrTokenTTL = 11 * time.Hour
ociImageVersionLabel = "org.opencontainers.image.version"
versionLabelCacheTTL = 3 * time.Hour
)
@@ -102,6 +103,7 @@ type ContainerRegistryService struct {
db *database.DB
dockerClient registryDaemonGetter
cache *hot.HotCache[string, string]
+ digestFailures *hot.HotCache[string, error]
labelCache *hot.HotCache[string, string]
ecrRefreshGroup singleflight.Group
distributionHTTPClient *http.Client
@@ -157,6 +159,10 @@ func NewContainerRegistryService(
WithRevalidationErrorPolicy(hot.KeepOnError).
WithJanitor().
Build(),
+ digestFailures: hot.NewHotCache[string, error](hot.LRU, 1024).
+ WithTTL(registryDigestFailureTTL).
+ WithJanitor().
+ Build(),
// No static loader: ImageVersionLabel uses GetWithLoaders so failed resolutions retry on the next request.
labelCache: hot.NewHotCache[string, string](hot.LRU, 64).
WithTTL(versionLabelCacheTTL).
@@ -298,6 +304,9 @@ func (s *ContainerRegistryService) UpdateRegistry(ctx context.Context, id string
if err := normalization.Normalize(&req); err != nil {
return nil, err
}
+ if req.URL != nil && strings.TrimSpace(*req.URL) == "" {
+ return nil, common.Classify(common.ErrValidation, &base.FieldError{Field: "url", Err: errors.New("registry URL is required")})
+ }
registryRecord, err := s.GetRegistryByID(ctx, id)
if err != nil {
return nil, err
@@ -372,7 +381,7 @@ func (s *ContainerRegistryService) UpdateRegistry(ctx context.Context, id string
URL: mo.PointerToOption(req.URL).OrElse(registryRecord.URL),
Username: kit.Ternary(registryRecord.RegistryType == RegistryTypeECR, registryRecord.Username, mo.PointerToOption(req.Username).OrElse(registryRecord.Username)),
Token: cmp.Or(encryptedToken, registryRecord.Token),
- Description: req.Description,
+ Description: kit.Ternary(req.Description == nil, registryRecord.Description, req.Description),
Insecure: mo.PointerToOption(req.Insecure).OrElse(registryRecord.Insecure),
Enabled: mo.PointerToOption(req.Enabled).OrElse(registryRecord.Enabled),
RegistryType: registryRecord.RegistryType,
@@ -442,30 +451,42 @@ func (s *ContainerRegistryService) GetRegistryAuthForImage(ctx context.Context,
if s == nil {
return "", nil
}
- registryHost, err := registryauth.GetRegistryAddress(imageRef)
+ named, err := reference.ParseNormalizedNamed(imageRef)
if err != nil {
return "", err
}
- return s.GetRegistryAuthForHost(ctx, registryHost)
-}
-
-// GetRegistryAuthForHost returns X-Registry-Auth for a configured and enabled registry.
-func (s *ContainerRegistryService) GetRegistryAuthForHost(ctx context.Context, registryHost string) (string, error) {
- if s == nil || registryauth.NormalizeRegistryForComparison(registryHost) == "" {
+ registryHost, repository := reference.Domain(named), reference.Path(named)
+ if registryauth.NormalizeRegistryForComparison(registryHost) == "" {
return "", nil
}
- authConfigs, err := s.GetAllRegistryAuthConfigs(ctx)
+ registries, err := s.GetEnabledRegistries(ctx)
if err != nil {
return "", err
}
- cfg, ok := authConfigs[registryauth.NormalizeRegistryForComparison(registryHost)]
- if !ok {
- return "", nil
- }
+ candidates := slices.DeleteFunc(registries, func(reg ContainerRegistry) bool {
+ _, namespace := registryauth.SplitRegistryURL(reg.URL)
+ return !registryauth.IsRegistryMatch(reg.URL, registryHost) ||
+ (namespace != "" && repository != namespace && !strings.HasPrefix(repository, namespace+"/"))
+ })
+ slices.SortStableFunc(candidates, func(a, b ContainerRegistry) int {
+ _, namespaceA := registryauth.SplitRegistryURL(a.URL)
+ _, namespaceB := registryauth.SplitRegistryURL(b.URL)
+ return cmp.Compare(len(namespaceB), len(namespaceA))
+ })
- return registryauth.EncodeAuthHeader(cfg.Username, cfg.Password, cfg.ServerAddress)
+ for i := range candidates {
+ credential, credErr := s.credentialForRegistry(ctx, &candidates[i])
+ if credErr != nil {
+ slog.WarnContext(ctx, "failed to resolve registry credential, skipping", "registry", candidates[i].URL, "error", credErr)
+ continue
+ }
+ if credential != nil {
+ return registryauth.EncodeAuthHeader(credential.Username, credential.Token, credential.ServerAddress)
+ }
+ }
+ return "", nil
}
func (s *ContainerRegistryService) GetAllRegistryAuthConfigs(ctx context.Context) (map[string]dockerregistry.AuthConfig, error) {
@@ -722,6 +743,10 @@ func (s *ContainerRegistryService) ImageDigest(ctx context.Context, imageRef str
return "", err
}
+ if cachedErr, failed, _ := s.digestFailures.Get(parts.NormalizedRef); failed {
+ return "", cachedErr
+ }
+
digestValue, found, err := s.cache.GetWithLoaders(parts.NormalizedRef, func(_ []string) (map[string]string, error) {
loadCtx, cancel := context.WithTimeout(ctx, timeouts.DefaultRegistry)
defer cancel()
@@ -733,6 +758,9 @@ func (s *ContainerRegistryService) ImageDigest(ctx context.Context, imageRef str
return map[string]string{parts.NormalizedRef: result.Digest}, nil
})
if err != nil {
+ if ctx.Err() == nil {
+ s.digestFailures.Set(parts.NormalizedRef, err)
+ }
return "", err
}
if !found {
@@ -802,8 +830,8 @@ func (s *ContainerRegistryService) InspectImageDigest(ctx context.Context, image
return result, nil
}
if isRateLimitError(daemonErr) {
- slog.DebugContext(ctx, "rate limited by registry, will retry", "registry", parts.RegistryHost, "imageRef", parts.NormalizedRef)
- return nil, daemonErr
+ slog.DebugContext(ctx, "rate limited by registry", "registry", parts.RegistryHost, "imageRef", parts.NormalizedRef)
+ return nil, backoff.Permanent(daemonErr)
}
if !registry.IsFallbackEligibleDaemonError(daemonErr) &&
(browse.IsUnauthorizedRegistryError(daemonErr) || !slices.ContainsFunc([]string{
@@ -837,8 +865,8 @@ func (s *ContainerRegistryService) InspectImageDigest(ctx context.Context, image
return fallbackResult, nil
}
if isRateLimitError(fallbackErr) {
- slog.DebugContext(ctx, "rate limited by registry on fallback, will retry", "registry", parts.RegistryHost, "imageRef", parts.NormalizedRef)
- return nil, fallbackErr
+ slog.DebugContext(ctx, "rate limited by registry on fallback", "registry", parts.RegistryHost, "imageRef", parts.NormalizedRef)
+ return nil, backoff.Permanent(fallbackErr)
}
lastErr = fmt.Errorf("daemon digest lookup failed; registry fallback failed: %w", errors.Join(daemonErr, fallbackErr))
@@ -1195,6 +1223,8 @@ func (s *ContainerRegistryService) GetOrRefreshECRToken(ctx context.Context, reg
}
result, refreshErr, _ := s.ecrRefreshGroup.Do(reg.ID, func() (any, error) {
+ refreshCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), timeouts.DefaultRegistry)
+ defer cancel()
// Without a static access key, the default AWS credential chain applies (env, shared config, ECS task role, EC2 instance profile).
secretKey, decErr := crypto.Decrypt(kit.Ternary(strings.TrimSpace(reg.AWSAccessKeyID) != "", reg.AWSSecretAccessKey, ""))
if decErr != nil {
@@ -1204,7 +1234,7 @@ func (s *ContainerRegistryService) GetOrRefreshECRToken(ctx context.Context, reg
return nil, fmt.Errorf("AWS secret access key is empty for registry %s", reg.URL)
}
- cfg, cfgErr := config.LoadDefaultConfig(context.WithoutCancel(ctx),
+ cfg, cfgErr := config.LoadDefaultConfig(refreshCtx,
config.WithRegion(reg.AWSRegion),
kit.Ternary(strings.TrimSpace(reg.AWSAccessKeyID) != "",
config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(reg.AWSAccessKeyID, strings.TrimSpace(secretKey), "")),
@@ -1214,7 +1244,7 @@ func (s *ContainerRegistryService) GetOrRefreshECRToken(ctx context.Context, reg
if cfgErr != nil {
return nil, fmt.Errorf("failed to load AWS config for registry %s: %w", reg.URL, cfgErr)
}
- tokenOutput, ecrErr := ecr.NewFromConfig(cfg).GetAuthorizationToken(context.WithoutCancel(ctx), &ecr.GetAuthorizationTokenInput{})
+ tokenOutput, ecrErr := ecr.NewFromConfig(cfg).GetAuthorizationToken(refreshCtx, &ecr.GetAuthorizationTokenInput{})
if ecrErr != nil {
return nil, fmt.Errorf("failed to get ECR authorization token for registry %s: %w", reg.URL, ecrErr)
}
diff --git a/backend/internal/registry/service_test.go b/backend/internal/registry/service_test.go
index 886401d3f..aa79577ce 100644
--- a/backend/internal/registry/service_test.go
+++ b/backend/internal/registry/service_test.go
@@ -214,12 +214,12 @@ func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(
assert.Equal(t, "registry.example.com", exampleCfg.ServerAddress)
}
-func TestContainerRegistryService_GetRegistryAuthForHost_UsesDatabaseCredentials(t *testing.T) {
+func TestContainerRegistryService_GetRegistryAuthForImage_UsesDockerHubCredentials(t *testing.T) {
db := setupContainerRegistryTestDB(t)
createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
svc := NewContainerRegistryService(db, nil, nil, nil)
- auth, err := svc.GetRegistryAuthForHost(t.Context(), "registry-1.docker.io")
+ auth, err := svc.GetRegistryAuthForImage(t.Context(), "nginx:latest")
require.NoError(t, err)
require.NotEmpty(t, auth)
@@ -252,10 +252,6 @@ func TestContainerRegistryService_NilService_RegistryAuthMethodsReturnEmpty(t *t
require.NoError(t, err)
require.Nil(t, authConfigs)
- authForHost, err := svc.GetRegistryAuthForHost(ctx, "registry-1.docker.io")
- require.NoError(t, err)
- require.Empty(t, authForHost)
-
authForImage, err := svc.GetRegistryAuthForImage(ctx, "ghcr.io/getarcaneapp/arcane:latest")
require.NoError(t, err)
require.Empty(t, authForImage)
diff --git a/backend/internal/settings/model.go b/backend/internal/settings/model.go
index fa3a46d30..a06d78c2c 100644
--- a/backend/internal/settings/model.go
+++ b/backend/internal/settings/model.go
@@ -35,6 +35,7 @@ type settingFieldMeta struct {
isPublic bool
isVisibleToNonAdmin bool
isSensitive bool
+ isEncrypted bool
}
var settingsFieldCache struct {
@@ -182,10 +183,11 @@ type Settings struct {
ApnsChannelID SettingVariable `key:"apnsChannelId,internal"`
ApnsSigningKey SettingVariable `key:"apnsSigningKey,internal,sensitive"`
- AgentToken SettingVariable `key:"agentToken,internal,sensitive"`
- BrowserSessionSigningKey SettingVariable `key:"browserSessionSigningKey,internal,sensitive"`
- JwtSigningKeySeed SettingVariable `key:"jwtSigningKeySeed,internal,sensitive"`
- InstanceID SettingVariable `key:"instanceId,internal"`
+ AgentToken SettingVariable `key:"agentToken,internal,sensitive"`
+ BrowserSessionSigningKey SettingVariable `key:"browserSessionSigningKey,internal,sensitive"`
+ JwtSigningKeySeed SettingVariable `key:"jwtSigningKeySeed,internal,sensitive"`
+ InstanceID SettingVariable `key:"instanceId,internal"`
+ SensitiveSettingsEncrypted SettingVariable `key:"sensitiveSettingsEncrypted,internal"`
// Users category (admin management page - no actual settings)
UsersCategoryPlaceholder SettingVariable `key:"usersCategory,internal" meta:"label=Users;type=internal;keywords=users,accounts,management,admin,access,permissions,roles;category=users;description=Manage user accounts and permissions" catmeta:"id=users;title=Users;icon=user;url=/settings/users;description=Manage user accounts and access control"`
@@ -240,6 +242,7 @@ func buildSettingsFieldCacheInternal() {
isPublic: slices.Contains(attrList, "public"),
isVisibleToNonAdmin: slices.Contains(attrList, "public") || slices.Contains(attrList, "authrequired"),
isSensitive: slices.Contains(attrList, "sensitive"),
+ isEncrypted: slices.Contains(attrList, "sensitive") && !slices.Contains(attrList, "internal"),
}
ordered = append(ordered, meta)
byKey[key] = meta
diff --git a/backend/internal/settings/service.go b/backend/internal/settings/service.go
index 420274e2d..4a4fcc2ae 100644
--- a/backend/internal/settings/service.go
+++ b/backend/internal/settings/service.go
@@ -46,12 +46,15 @@ import (
)
const (
- browserSessionSigningKeySize = 64
+ browserSessionSigningKeySize = 64
+ minCiphertextBytes = 28
+ sensitiveSettingsEncryptedKey = "sensitiveSettingsEncrypted"
)
type SettingsService struct {
- db *database.DB
- config atomic.Pointer[Settings]
+ db *database.DB
+ appConfig *config.Config
+ config atomic.Pointer[Settings]
// effectiveConfig is the shared, read-only env-override-applied snapshot,
// rebuilt whenever config is stored so reads are a pointer load.
effectiveConfig atomic.Pointer[Settings]
@@ -72,12 +75,13 @@ type settingsEnvOverride struct {
value string
}
-func NewSettingsService(ctx context.Context, db *database.DB) (*SettingsService, error) {
+func NewSettingsService(ctx context.Context, db *database.DB, appConfig *config.Config) (*SettingsService, error) {
if ctx == nil {
return nil, errors.New("settings lifecycle context unavailable")
}
svc := &SettingsService{
db: db,
+ appConfig: appConfig,
effectsWake: make(chan struct{}, 1),
effectsDone: make(chan struct{}),
lifecycleCtx: ctx,
@@ -196,12 +200,23 @@ func (s *SettingsService) LoadDatabaseSettings(ctx context.Context) error {
}
dst := DefaultSettingsConfig()
- appCfg := config.Load()
- fields, _ := getSettingsFieldCacheInternal()
+ fields, byKey := getSettingsFieldCacheInternal()
+ for i := range stored {
+ if !byKey[stored[i].Key].isEncrypted || stored[i].Value == "" {
+ continue
+ }
+ plain, decryptErr := crypto.Decrypt(stored[i].Value)
+ switch {
+ case decryptErr == nil:
+ stored[i].Value = plain
+ case looksLikeCiphertext(stored[i].Value, decryptErr):
+ slog.WarnContext(ctx, "Failed to decrypt stored sensitive setting with the current encryption key", "key", stored[i].Key)
+ }
+ }
rv := reflect.ValueOf(dst).Elem()
- if appCfg.UIConfigurationDisabled || appCfg.AgentMode {
+ if s.appConfig.UIConfigurationDisabled || s.appConfig.AgentMode {
slog.DebugContext(ctx, "LoadDatabaseSettings: using env path",
- "uiConfigurationDisabled", appCfg.UIConfigurationDisabled, "agentMode", appCfg.AgentMode, "environment", appCfg.Environment)
+ "uiConfigurationDisabled", s.appConfig.UIConfigurationDisabled, "agentMode", s.appConfig.AgentMode, "environment", s.appConfig.Environment)
storedValues := make(map[string]string, len(stored))
for _, setting := range stored {
@@ -494,8 +509,9 @@ func (s *SettingsService) UpdateSettings(ctx context.Context, updates settings.U
}
cfg := s.GetSettingsConfig().Clone()
- oidcClientSecretUpdated := updates.OidcClientSecret != nil && !s.IsEnvOverrideActive("oidcClientSecret")
- trivyServerTokenUpdated := updates.TrivyServerToken != nil && *updates.TrivyServerToken != "" && !s.IsEnvOverrideActive("trivyServerToken")
+ oidcClientSecretUpdated := updates.OidcClientSecret != nil && *updates.OidcClientSecret != cfg.OidcClientSecret.Value && !s.IsEnvOverrideActive("oidcClientSecret")
+ trivyServerTokenProvided := updates.TrivyServerToken != nil && *updates.TrivyServerToken != ""
+ trivyServerTokenUpdated := trivyServerTokenProvided && *updates.TrivyServerToken != cfg.TrivyServerToken.Value && !s.IsEnvOverrideActive("trivyServerToken")
normalizeTargetURL := func(value string) string {
normalized, err := httpx.NormalizeBaseURL(value)
if err != nil {
@@ -541,7 +557,7 @@ func (s *SettingsService) UpdateSettings(ctx context.Context, updates settings.U
updates.TrivyServerUrl,
normalizeTargetURL,
map[string]bool{"trivyServerToken": cfg.TrivyServerToken.Value != ""},
- map[string]bool{"trivyServerToken": trivyServerTokenUpdated},
+ map[string]bool{"trivyServerToken": trivyServerTokenProvided},
); err != nil {
return nil, err
}
@@ -610,11 +626,15 @@ func (s *SettingsService) prepareUpdateValues(updates settings.Update, cfg, defa
if err := validateSettingValue(key, value); err != nil {
return nil, err
}
+ if s.IsEnvOverrideActive(key) {
+ continue
+ }
+ current, _, _, _ := cfg.FieldByKey(key)
if key == libarcane.DepotTokenSettingKey {
// Sensitive token: only update when explicitly provided.
// Empty input preserves existing token.
- if strings.TrimSpace(value) == "" {
+ if strings.TrimSpace(value) == "" || value == current {
continue
}
@@ -635,6 +655,9 @@ func (s *SettingsService) prepareUpdateValues(updates settings.Update, cfg, defa
if valueToSave == "" {
valueToSave, _, _, _ = defaultCfg.FieldByKey(key)
}
+ if valueToSave == current {
+ continue
+ }
err := cfg.UpdateField(key, valueToSave, true)
if errors.Is(err, SettingSensitiveForbiddenError{}) {
continue
@@ -650,11 +673,19 @@ func (s *SettingsService) prepareUpdateValues(updates settings.Update, cfg, defa
}
func (s *SettingsService) persistSettings(ctx context.Context, values []SettingVariable) error {
+ _, byKey := getSettingsFieldCacheInternal()
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
for _, setting := range values {
if setting.Key == "oidcProviderName" {
setting.Value = normalization.Text(setting.Value, true, true)
}
+ if byKey[setting.Key].isEncrypted && setting.Value != "" {
+ encrypted, encryptErr := crypto.Encrypt(setting.Value)
+ if encryptErr != nil {
+ return fmt.Errorf("failed to encrypt setting %s: %w", setting.Key, encryptErr)
+ }
+ setting.Value = encrypted
+ }
if err := tx.Save(&setting).Error; err != nil {
return fmt.Errorf("failed to update setting %s: %w", setting.Key, err)
}
@@ -745,15 +776,14 @@ func (s *SettingsService) PersistEnvSettingsIfMissing(ctx context.Context) error
return err
}
- appCfg := config.Load()
- isEnvOnlyMode := appCfg.AgentMode || appCfg.UIConfigurationDisabled
+ isEnvOnlyMode := s.appConfig.AgentMode || s.appConfig.UIConfigurationDisabled
fields, _ := getSettingsFieldCacheInternal()
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
for _, field := range fields {
attrs := splitSettingAttrsInternal(field.attrs)
// Outside env-only mode, only persist fields explicitly marked as envOverride.
- if slices.Contains(attrs, "internal") || (!isEnvOnlyMode && !slices.Contains(attrs, "envOverride")) {
+ if slices.Contains(attrs, "internal") || field.isSensitive || (!isEnvOnlyMode && !slices.Contains(attrs, "envOverride")) {
continue
}
envVal, ok, _ := utils.LookupEnvOrFile(settingEnvName(field.key))
@@ -786,6 +816,69 @@ func (s *SettingsService) PersistEnvSettingsIfMissing(ctx context.Context) error
return s.LoadDatabaseSettings(context.WithoutCancel(ctx))
}
+func (s *SettingsService) EncryptStoredSensitiveSettings(ctx context.Context) error {
+ s.writes.Lock()
+ defer s.writes.Unlock()
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+
+ fields, _ := getSettingsFieldCacheInternal()
+ keys := make([]string, 0, len(fields))
+ for _, field := range fields {
+ if field.isEncrypted {
+ keys = append(keys, field.key)
+ }
+ }
+
+ encryptedCount := 0
+ completed := false
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var marker SettingVariable
+ if findErr := tx.Where("key = ?", sensitiveSettingsEncryptedKey).Limit(1).Find(&marker).Error; findErr != nil {
+ return fmt.Errorf("load sensitive settings marker: %w", findErr)
+ }
+ if marker.Value == "true" {
+ completed = true
+ return nil
+ }
+ var stored []SettingVariable
+ if findErr := tx.Where("key IN ? AND value <> ''", keys).Find(&stored).Error; findErr != nil {
+ return fmt.Errorf("load sensitive settings: %w", findErr)
+ }
+ for _, setting := range stored {
+ if _, decryptErr := crypto.Decrypt(setting.Value); decryptErr == nil {
+ continue
+ }
+ encrypted, encryptErr := crypto.Encrypt(setting.Value)
+ if encryptErr != nil {
+ return fmt.Errorf("encrypt setting %s: %w", setting.Key, encryptErr)
+ }
+ if updateErr := tx.Model(&SettingVariable{}).Where("key = ?", setting.Key).Update("value", encrypted).Error; updateErr != nil {
+ return fmt.Errorf("update setting %s: %w", setting.Key, updateErr)
+ }
+ encryptedCount++
+ }
+ if saveErr := tx.Save(&SettingVariable{Key: sensitiveSettingsEncryptedKey, Value: "true"}).Error; saveErr != nil {
+ return fmt.Errorf("save sensitive settings marker: %w", saveErr)
+ }
+ return nil
+ }); err != nil {
+ return err
+ }
+ if completed {
+ return nil
+ }
+ slog.InfoContext(ctx, "Encrypted stored sensitive settings", "count", encryptedCount)
+ return s.LoadDatabaseSettings(context.WithoutCancel(ctx))
+}
+
+func looksLikeCiphertext(value string, decryptErr error) bool {
+ _, isDecryptErr := errors.AsType[*crypto.DecryptError](decryptErr)
+ decoded, decodeErr := base64.StdEncoding.DecodeString(value)
+ return isDecryptErr && decodeErr == nil && len(decoded) >= minCiphertextBytes
+}
+
func (s *SettingsService) ListSettings(visibility SettingVisibility) []SettingVariable {
return s.GetSettingsConfig().ToSettingVariableSlice(visibility, true)
}
diff --git a/backend/internal/settings/service_test.go b/backend/internal/settings/service_test.go
index e135751a1..46c87c649 100644
--- a/backend/internal/settings/service_test.go
+++ b/backend/internal/settings/service_test.go
@@ -34,7 +34,8 @@ func setupSettingsTestDB(t *testing.T) *database.DB {
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*SettingsService, error) {
t.Helper()
- svc, err := NewSettingsService(ctx, db)
+ crypto.InitEncryption(&crypto.Config{Environment: "development"})
+ svc, err := NewSettingsService(ctx, db, config.Load())
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
@@ -1355,3 +1356,58 @@ func TestSettingsService_SwarmFeatureDefaultsOffAndPersists(t *testing.T) {
_, err = svc.UpdateSettings(t.Context(), settings.Update{FeatureSwarmEnabled: &invalid})
require.ErrorIs(t, err, common.ErrValidation)
}
+
+func TestSettingsServiceEncryptsSensitiveSettingsAtRest(t *testing.T) {
+ ctx := t.Context()
+ db := setupSettingsTestDB(t)
+ svc, err := newSettingsServiceForTest(t, ctx, db)
+ require.NoError(t, err)
+
+ require.NoError(t, svc.UpdateSetting(ctx, "oidcClientSecret", "client-secret"))
+ var stored SettingVariable
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "oidcClientSecret").First(&stored).Error)
+ require.NotEqual(t, "client-secret", stored.Value)
+ require.Equal(t, "client-secret", svc.GetSettingsConfig().OidcClientSecret.Value)
+
+ hexToken := strings.Repeat("0123456789abcdef", 4)
+ require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "trivyServerToken", Value: "legacy-token"}).Error)
+ require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "depotToken", Value: hexToken}).Error)
+ require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))
+ var storedToken, storedHexToken SettingVariable
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "trivyServerToken").First(&storedToken).Error)
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "depotToken").First(&storedHexToken).Error)
+ require.NotEqual(t, "legacy-token", storedToken.Value)
+ require.NotEqual(t, hexToken, storedHexToken.Value)
+ require.Equal(t, "legacy-token", svc.GetSettingsConfig().TrivyServerToken.Value)
+ require.Equal(t, hexToken, svc.GetSettingsConfig().DepotToken.Value)
+
+ var rerunClientSecret SettingVariable
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "oidcClientSecret").First(&rerunClientSecret).Error)
+ require.Equal(t, stored.Value, rerunClientSecret.Value)
+}
+
+func TestSettingsServiceEncryptsStoredSensitiveSettingsOnlyOnce(t *testing.T) {
+ ctx := t.Context()
+ db := setupSettingsTestDB(t)
+ svc, err := newSettingsServiceForTest(t, ctx, db)
+ require.NoError(t, err)
+
+ require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))
+ var marker SettingVariable
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "sensitiveSettingsEncrypted").First(&marker).Error)
+ require.Equal(t, "true", marker.Value)
+
+ otherKey, err := crypto.GenerateKey()
+ require.NoError(t, err)
+ otherEncryptor, err := crypto.New(otherKey)
+ require.NoError(t, err)
+ foreignCiphertext, err := otherEncryptor.Encrypt("secret-from-another-key")
+ require.NoError(t, err)
+
+ require.NoError(t, db.WithContext(ctx).Save(&SettingVariable{Key: "depotToken", Value: foreignCiphertext}).Error)
+ require.NoError(t, svc.EncryptStoredSensitiveSettings(ctx))
+
+ var stored SettingVariable
+ require.NoError(t, db.WithContext(ctx).Where("key = ?", "depotToken").First(&stored).Error)
+ require.Equal(t, foreignCiphertext, stored.Value)
+}
diff --git a/backend/internal/swarm/children/nodes/service_test.go b/backend/internal/swarm/children/nodes/service_test.go
index bb884523b..8c2278bc7 100644
--- a/backend/internal/swarm/children/nodes/service_test.go
+++ b/backend/internal/swarm/children/nodes/service_test.go
@@ -15,6 +15,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
@@ -31,7 +32,7 @@ func setupSwarmServiceTestDB(t *testing.T) *database.DB {
func newSettingsServiceForSwarmTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/swarm/children/stacks/service_test.go b/backend/internal/swarm/children/stacks/service_test.go
index f3832924f..7082f2ef6 100644
--- a/backend/internal/swarm/children/stacks/service_test.go
+++ b/backend/internal/swarm/children/stacks/service_test.go
@@ -11,6 +11,7 @@ import (
"github.com/stretchr/testify/require"
"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/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
@@ -26,7 +27,7 @@ func setupSwarmServiceTestDB(t *testing.T) *database.DB {
func newSettingsServiceForSwarmTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/system/children/backup/service_test.go b/backend/internal/system/children/backup/service_test.go
index 644e8322a..5ce79c4cc 100644
--- a/backend/internal/system/children/backup/service_test.go
+++ b/backend/internal/system/children/backup/service_test.go
@@ -31,7 +31,7 @@ func TestHistoryDestinationDecoration(t *testing.T) {
destination := s3.S3Destination{Name: "Offsite", Bucket: "backups"}
require.NoError(t, db.Create(&destination).Error)
store := &database.DB{DB: db}
- settingsService, err := settings.NewSettingsService(t.Context(), store)
+ settingsService, err := settings.NewSettingsService(t.Context(), store, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
service := NewService(Dependencies{
@@ -74,7 +74,7 @@ func TestRecoveryEnvironmentIncludesRuntimeSecrets(t *testing.T) {
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&settings.SettingVariable{}))
- settingsService, err := settings.NewSettingsService(t.Context(), &database.DB{DB: db})
+ settingsService, err := settings.NewSettingsService(t.Context(), &database.DB{DB: db}, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
environment := NewService(Dependencies{
diff --git a/backend/internal/system/children/prune/service.go b/backend/internal/system/children/prune/service.go
index c90abb725..3b7d9d58a 100644
--- a/backend/internal/system/children/prune/service.go
+++ b/backend/internal/system/children/prune/service.go
@@ -20,13 +20,14 @@ import (
"github.com/getarcaneapp/arcane/types/v2/user"
"github.com/moby/moby/client"
"github.com/samber/mo"
+ "go.getarcane.app/docker"
"go.getarcane.app/docker/compat"
kit "go.getarcane.app/kit/pkg"
"golang.org/x/sync/errgroup"
"github.com/getarcaneapp/arcane/backend/v2/internal/activity"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
- "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
+ dockerInternal "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"
"github.com/getarcaneapp/arcane/backend/v2/internal/network"
"github.com/getarcaneapp/arcane/backend/v2/internal/volume"
@@ -39,7 +40,7 @@ import (
// Service runs manual and scheduled prunes, serializing them per environment.
type Service struct {
location *time.Location
- dockerService *docker.DockerClientService
+ dockerService *dockerInternal.DockerClientService
activityService *activity.ActivityService
imageUpdateService *imageupdate.ImageUpdateService
volumeService *volume.VolumeService
@@ -50,7 +51,7 @@ type Service struct {
func NewService(
location *time.Location,
- dockerService *docker.DockerClientService,
+ dockerService *dockerInternal.DockerClientService,
activityService *activity.ActivityService,
imageUpdateService *imageupdate.ImageUpdateService,
volumeService *volume.VolumeService,
@@ -258,6 +259,7 @@ func (s *Service) runSystemPrune(ctx context.Context, req system.PruneAllRequest
if err := g.Wait(); err != nil {
slog.ErrorContext(ctx, "Prune operations failed", "error", err)
+ addError("Prune worker failed: %v", err)
}
result := &system.PruneAllResult{
@@ -388,29 +390,38 @@ func (s *Service) pruneImages(ctx context.Context, options system.PruneImagesOpt
if err != nil {
return system.PruneAllResult{}, fmt.Errorf("failed to prune images: %w", err)
}
+ existing, listErr := cli.ImageList(ctx, client.ImageListOptions{})
+ if listErr != nil {
+ slog.WarnContext(ctx, "Failed to list images before prune; deleted counts may include layers", "error", listErr)
+ }
+ existingIDs := make(map[string]struct{}, len(existing.Items))
+ for _, item := range existing.Items {
+ existingIDs[item.ID] = struct{}{}
+ }
+
report, err := cli.ImagePrune(ctx, client.ImagePruneOptions{Filters: filterArgs})
if err != nil {
return system.PruneAllResult{}, fmt.Errorf("failed to prune images: %w", err)
}
- slog.InfoContext(ctx, "Image pruning completed", "imagesDeleted", len(report.Report.ImagesDeleted), "bytesReclaimed", report.Report.SpaceReclaimed)
-
- // Collect IDs to delete from DB
- var idsToDelete []string
+ var deletedImageIDs, untaggedRefs []string
for _, imgReport := range report.Report.ImagesDeleted {
- if imgReport.Deleted != "" {
- idsToDelete = append(idsToDelete, imgReport.Deleted)
- } else if imgReport.Untagged != "" {
- idsToDelete = append(idsToDelete, imgReport.Untagged)
+ _, isImage := existingIDs[imgReport.Deleted]
+ switch {
+ case imgReport.Deleted != "" && (isImage || listErr != nil):
+ deletedImageIDs = append(deletedImageIDs, imgReport.Deleted)
+ case imgReport.Untagged != "":
+ untaggedRefs = append(untaggedRefs, imgReport.Untagged)
}
}
+ slog.InfoContext(ctx, "Image pruning completed", "imagesDeleted", len(deletedImageIDs), "bytesReclaimed", report.Report.SpaceReclaimed)
- if deleteRecordsForImagesErr := s.imageUpdateService.DeleteRecordsForImages(ctx, idsToDelete); deleteRecordsForImagesErr != nil {
- slog.WarnContext(ctx, "Failed to delete image update records", "count", len(idsToDelete), "error", deleteRecordsForImagesErr.Error())
+ if deleteRecordsForImagesErr := s.imageUpdateService.DeleteRecordsForImages(ctx, slices.Concat(deletedImageIDs, untaggedRefs)); deleteRecordsForImagesErr != nil {
+ slog.WarnContext(ctx, "Failed to delete image update records", "count", len(deletedImageIDs)+len(untaggedRefs), "error", deleteRecordsForImagesErr.Error())
}
return system.PruneAllResult{
- ImagesDeleted: idsToDelete,
+ ImagesDeleted: deletedImageIDs,
SpaceReclaimed: report.Report.SpaceReclaimed,
ImageSpaceReclaimed: report.Report.SpaceReclaimed,
}, nil
@@ -631,7 +642,7 @@ func (s *Service) selectPruneImages(req system.PruneAllRequest, usage client.Dis
resources = append(resources, pruneResource{
Kind: "image",
ID: item.ID,
- Size: item.Size,
+ Size: kit.Ternary(item.SharedSize >= 0, item.Size-item.SharedSize, 0),
Names: slices.Clone(item.RepoTags),
})
}
@@ -972,49 +983,63 @@ func (s *Service) pruneResourceEligible(ctx context.Context, plan prunePlan, res
}
return resource.Size, len(inspected.Network.Containers) == 0 && !inspected.Network.Ingress, true, nil
}
- usage, err := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.DiskUsageResult, error) {
- return cli.DiskUsage(ctx, client.DiskUsageOptions{
- Containers: resource.Kind == "container",
- Images: resource.Kind == "image",
- Volumes: resource.Kind == "volume",
- Verbose: true,
- })
- })
- if err != nil {
- return resource.Size, false, false, err
- }
switch resource.Kind {
case "container":
- for _, item := range usage.Containers.Items {
- if item.ID == resource.ID {
- return item.SizeRw, item.State != "running" && item.State != "paused" && item.State != "restarting", true, nil
- }
+ inspected, inspectErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ContainerInspectResult, error) {
+ return compat.ContainerInspectWithCompatibility(ctx, cli, resource.ID, client.ContainerInspectOptions{})
+ })
+ if errdefs.IsNotFound(inspectErr) {
+ return resource.Size, false, false, nil
+ }
+ if inspectErr != nil {
+ return resource.Size, false, false, inspectErr
}
+ state := kit.FromPtr(inspected.Container.State)
+ return resource.Size, !state.Running && !state.Paused && !state.Restarting, true, nil
case "image":
- for _, item := range usage.Images.Items {
- if item.ID != resource.ID {
- continue
- }
- // Size - SharedSize is the unique layer size Docker counts as reclaimable for an unused image.
- reclaimable := kit.Ternary(item.SharedSize >= 0, item.Size-item.SharedSize, 0)
- if slices.ContainsFunc(item.RepoTags, func(tag string) bool { return !slices.Contains(resource.Names, tag) }) {
- return reclaimable, false, true, nil
- }
- return reclaimable, item.Containers == 0 && (plan.Request.Images.Mode != system.PruneImageModeDangling || len(item.RepoTags) == 0), true, nil
+ inspected, inspectErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ImageInspectResult, error) {
+ return cli.ImageInspect(ctx, resource.ID)
+ })
+ if errdefs.IsNotFound(inspectErr) {
+ return resource.Size, false, false, nil
+ }
+ if inspectErr != nil {
+ return resource.Size, false, false, inspectErr
+ }
+ if slices.ContainsFunc(inspected.RepoTags, func(tag string) bool { return !slices.Contains(resource.Names, tag) }) {
+ return resource.Size, false, true, nil
}
+ users, listErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ContainerListResult, error) {
+ return cli.ContainerList(ctx, client.ContainerListOptions{
+ All: true,
+ Filters: make(client.Filters).Add("ancestor", resource.ID),
+ })
+ })
+ if listErr != nil {
+ return resource.Size, false, true, listErr
+ }
+ return resource.Size, len(users.Items) == 0 && (plan.Request.Images.Mode != system.PruneImageModeDangling || len(inspected.RepoTags) == 0), true, nil
case "volume":
- for _, item := range usage.Volumes.Items {
- if item.Name != resource.ID {
- continue
- }
- if item.UsageData == nil {
- return resource.Size, false, true, nil
- }
- return item.UsageData.Size, item.UsageData.RefCount == 0 && !strings.EqualFold(item.Labels[libarcane.InternalResourceLabel], "true") &&
- !s.volumeService.IsBackupVolume(item.Name), true, nil
+ inspected, inspectErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.VolumeInspectResult, error) {
+ return cli.VolumeInspect(ctx, resource.ID, client.VolumeInspectOptions{})
+ })
+ if errdefs.IsNotFound(inspectErr) {
+ return resource.Size, false, false, nil
}
+ if inspectErr != nil {
+ return resource.Size, false, false, inspectErr
+ }
+ users, usersErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) ([]string, error) {
+ return docker.GetContainersUsingVolume(ctx, cli, resource.ID)
+ })
+ if usersErr != nil {
+ return resource.Size, false, true, usersErr
+ }
+ return resource.Size, len(users) == 0 && !strings.EqualFold(inspected.Volume.Labels[libarcane.InternalResourceLabel], "true") &&
+ !s.volumeService.IsBackupVolume(inspected.Volume.Name), true, nil
+ default:
+ return resource.Size, false, false, nil
}
- return resource.Size, false, false, nil
}
func (s *Service) ReconcileScheduledPrune(ctx context.Context, previous scheduler.Run) (scheduler.Outcome, error) {
diff --git a/backend/internal/system/children/prune/service_test.go b/backend/internal/system/children/prune/service_test.go
index 4e029427e..70c87e096 100644
--- a/backend/internal/system/children/prune/service_test.go
+++ b/backend/internal/system/children/prune/service_test.go
@@ -34,6 +34,12 @@ func TestPruneVolumesSkipsBackupVolume(t *testing.T) {
_, _ = fmt.Fprint(w, `{"Volumes":[`+
`{"Name":"orphan","Driver":"local","UsageData":{"RefCount":0,"Size":100}},`+
`{"Name":"arcane-backups","Driver":"local","UsageData":{"RefCount":0,"Size":200}}]}`)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = fmt.Fprint(w, `[]`)
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/volumes/"):
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = fmt.Fprint(w, `{"Name":"`+path.Base(r.URL.Path)+`","Driver":"local"}`)
case r.Method == http.MethodDelete && strings.Contains(r.URL.Path, "/volumes/"):
mu.Lock()
deleted = append(deleted, path.Base(r.URL.Path))
diff --git a/backend/internal/system/children/upgrade/service.go b/backend/internal/system/children/upgrade/service.go
index faf16bbf1..305f50ecb 100644
--- a/backend/internal/system/children/upgrade/service.go
+++ b/backend/internal/system/children/upgrade/service.go
@@ -45,6 +45,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
"github.com/getarcaneapp/arcane/backend/v2/internal/project"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/registry"
"github.com/getarcaneapp/arcane/backend/v2/internal/role"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/version"
@@ -100,6 +101,7 @@ type Service struct {
eventService *event.EventService
settingsService *settings.SettingsService
projectService *project.ProjectService
+ registryService *registry.ContainerRegistryService
// resolveRuntimeOptions determines how the upgrader container reaches the Docker daemon.
resolveRuntimeOptions func(
ctx context.Context,
@@ -150,6 +152,7 @@ func NewService(
eventService *event.EventService,
settingsService *settings.SettingsService,
projectService *project.ProjectService,
+ registryService *registry.ContainerRegistryService,
resolveRuntimeOptions func(
ctx context.Context,
dockerHost string,
@@ -166,6 +169,7 @@ func NewService(
eventService: eventService,
settingsService: settingsService,
projectService: projectService,
+ registryService: registryService,
resolveRuntimeOptions: resolveRuntimeOptions,
}
}
@@ -231,8 +235,28 @@ func (s *Service) TriggerUpgradeAsync(ctx context.Context, user usertypes.Actor,
runCtx, cancel := context.WithTimeout(utils.ActivityRuntimeContext(ctx, nil), runTimeout)
go func() {
defer cancel()
- if _, runPreparedUpgradeErr := s.runPreparedUpgrade(runCtx, prepared); runPreparedUpgradeErr != nil {
- slog.ErrorContext(ctx, "Background self-upgrade failed", "error", runPreparedUpgradeErr, "targetImage", prepared.targetImage)
+ _, runPreparedUpgradeErr := s.runPreparedUpgrade(runCtx, prepared)
+ if runPreparedUpgradeErr == nil {
+ return
+ }
+ slog.ErrorContext(ctx, "Background self-upgrade failed", "error", runPreparedUpgradeErr, "targetImage", prepared.targetImage)
+ eventCtx, eventCancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
+ defer eventCancel()
+ if _, createEventErr := s.eventService.CreateEvent(eventCtx, event.CreateEventRequest{
+ Type: event.EventTypeSystemUpgrade,
+ Severity: event.EventSeverityError,
+ Title: "Self-upgrade failed",
+ Description: runPreparedUpgradeErr.Error(),
+ UserID: new(user.ID),
+ Username: new(user.Username),
+ Metadata: database.JSON{
+ "action": "system_upgrade_cli",
+ "containerName": prepared.containerName,
+ "targetImage": prepared.targetImage,
+ "pullImage": prepared.pullImage,
+ },
+ }); createEventErr != nil {
+ slog.WarnContext(eventCtx, "Failed to log self-upgrade failure event", "error", createEventErr)
}
}()
return nil
@@ -253,6 +277,17 @@ func (s *Service) prepareUpgrade(ctx context.Context, user usertypes.Actor, targ
if err != nil {
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
+ runningUpgraders, err := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ContainerListResult, error) {
+ return cli.ContainerList(ctx, client.ContainerListOptions{
+ Filters: make(client.Filters).Add("label", libarcane.LabelArcaneUpgrader+"=true").Add("status", "running"),
+ })
+ })
+ if err != nil {
+ return nil, fmt.Errorf("check for running upgraders: %w", err)
+ }
+ if len(runningUpgraders.Items) > 0 {
+ return nil, common.Classify(common.ErrUpgradeInProgress, errors.New("an upgrader container is already running"))
+ }
current, err := func() (container.InspectResponse, error) {
containerID := strings.TrimSpace(target.ContainerID)
if containerID == "" {
@@ -345,7 +380,11 @@ func (s *Service) runPreparedUpgrade(ctx context.Context, prepared *preparedUpgr
pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(localSettings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
defer pullCancel()
- pullReader, err := dockerClient.ImagePull(pullCtx, prepared.pullImage, client.ImagePullOptions{})
+ registryAuth, err := s.registryService.GetRegistryAuthForImage(pullCtx, prepared.pullImage)
+ if err != nil {
+ slog.WarnContext(ctx, "Failed to resolve registry credentials for upgrader image; pulling anonymously", "image", prepared.pullImage, "error", err)
+ }
+ pullReader, err := dockerClient.ImagePull(pullCtx, prepared.pullImage, client.ImagePullOptions{RegistryAuth: registryAuth})
if err != nil {
if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
return "", fmt.Errorf("upgrader image pull timed out for %s (increase DOCKER_IMAGE_PULL_TIMEOUT or setting)", prepared.pullImage)
@@ -435,8 +474,8 @@ func (s *Service) runPreparedUpgrade(ctx context.Context, prepared *preparedUpgr
User: "0:0",
Env: containerEnv,
Labels: map[string]string{
- "com.getarcaneapp.arcane.upgrader": "true",
- "com.getarcaneapp.arcane": "true",
+ libarcane.LabelArcaneUpgrader: "true",
+ "com.getarcaneapp.arcane": "true",
},
},
HostConfig: &container.HostConfig{
@@ -594,7 +633,7 @@ func (s *Service) StartUpdateAll(ctx context.Context, user usertypes.Actor) (*En
Username: user.Username,
ManagerVersionAtStart: info.CurrentVersion,
ManagerDigestAtStart: info.CurrentDigest,
- ManagerTargetVersion: cmp.Or(info.NewestVersion, info.NewestDigest, info.CurrentVersion, info.CurrentDigest),
+ ManagerTargetVersion: cmp.Or(info.NewestVersion, info.NewestDigest),
// The manager row stays pending until the final manager step.
Results: EnvironmentUpdateResults{{
EnvironmentID: environment.LocalEnvironmentID,
@@ -868,7 +907,13 @@ func (s *Service) upgradeAgentTask(ctx context.Context, t flow.Task) (_ any, err
}
stage(EnvironmentUpdateStageVerifying)
// An unconfirmed request proves nothing by the agent merely matching the target, so it needs a real change.
- if upgradeLanded(info.CurrentVersion, info.CurrentDigest, kit.Ternary(unconfirmed, "", result.ToVersion), current.CurrentVersion, current.CurrentDigest) {
+ if upgradeLanded(
+ info.CurrentVersion,
+ info.CurrentDigest,
+ kit.Ternary(unconfirmed || strings.TrimPrefix(result.ToVersion, "v") == strings.TrimPrefix(info.CurrentVersion, "v") || result.ToVersion == info.CurrentDigest, "", result.ToVersion),
+ current.CurrentVersion,
+ current.CurrentDigest,
+ ) {
settle(EnvironmentUpdateResultStatusUpdated, result.Error)
return nil, nil
}
diff --git a/backend/internal/system/children/upgrade/service_test.go b/backend/internal/system/children/upgrade/service_test.go
index 33d0af10e..8967064b8 100644
--- a/backend/internal/system/children/upgrade/service_test.go
+++ b/backend/internal/system/children/upgrade/service_test.go
@@ -18,6 +18,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
dockerInternal "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
@@ -35,7 +36,7 @@ var testDockerService = &dockerInternal.DockerClientService{Client: func() *clie
// TestService_UpgradeFlag tests the upgrading flag behavior
func TestService_UpgradeFlag(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Initially should be false
require.False(t, s.upgrading.Load())
@@ -51,7 +52,7 @@ func TestService_UpgradeFlag(t *testing.T) {
// TestService_Initialization tests proper initialization
func TestService_Initialization(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
require.NotNil(t, s)
require.False(t, s.upgrading.Load())
@@ -75,7 +76,7 @@ func TestService_ErrorVariables(t *testing.T) {
// TestService_UpgradingFlag_ConcurrentAccess tests upgrading flag
func TestService_UpgradingFlag_ConcurrentAccess(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Test initial state
require.False(t, s.upgrading.Load(), "upgrading flag should start as false")
@@ -91,7 +92,7 @@ func TestService_UpgradingFlag_ConcurrentAccess(t *testing.T) {
// TestService_CompareAndSwap tests atomic CompareAndSwap operation
func TestService_CompareAndSwap(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Test successful CompareAndSwap from false to true
swapped := s.upgrading.CompareAndSwap(false, true)
@@ -112,7 +113,7 @@ func TestService_CompareAndSwap(t *testing.T) {
// TestService_Services tests that services are stored correctly
func TestService_Services(t *testing.T) {
// Create upgrade service with nil services (valid for testing initialization)
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Verify service is created and initialized properly
require.NotNil(t, s)
@@ -121,7 +122,7 @@ func TestService_Services(t *testing.T) {
// TestService_ConcurrentUpgradeAttempts tests that concurrent upgrade attempts are prevented
func TestService_ConcurrentUpgradeAttempts(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Simulate first upgrade starting
success := s.upgrading.CompareAndSwap(false, true)
@@ -152,7 +153,7 @@ func TestService_UpgradeInProgressError(t *testing.T) {
// TestService_AtomicOperations tests atomic.Bool operations
func TestService_AtomicOperations(t *testing.T) {
- s := NewService(nil, nil, nil, nil, nil, nil, nil)
+ s := NewService(nil, nil, nil, nil, nil, nil, nil, nil)
// Test Load
require.False(t, s.upgrading.Load())
@@ -332,7 +333,7 @@ func TestResolveSelfUpgradeTargetImage(t *testing.T) {
require.NoError(t, db.AutoMigrate(&project.Project{}, &settings.SettingVariable{}))
directory := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", directory)
- settingsSvc, err := settings.NewSettingsService(t.Context(), db)
+ settingsSvc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsSvc.Stop(context.WithoutCancel(t.Context()))) })
require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "projectsDirectory", directory))
@@ -344,7 +345,7 @@ func TestResolveSelfUpgradeTargetImage(t *testing.T) {
}
require.NoError(t, db.Create(&project.Project{ID: "project-arcane", Name: "arcane", Path: projectPath}).Error)
}
- svc := NewService(db, nil, nil, nil, nil, project.NewProjectService(db, settingsSvc, nil, nil, testDockerService, nil, nil, nil, nil, nil, nil), nil)
+ svc := NewService(db, nil, nil, nil, nil, project.NewProjectService(db, settingsSvc, nil, nil, testDockerService, nil, nil, nil, nil, nil, nil), nil, nil)
current := container.InspectResponse{Config: &container.Config{
Image: tt.runtime,
Labels: map[string]string{"com.docker.compose.project": "arcane", "com.docker.compose.service": "server"},
@@ -489,7 +490,7 @@ func TestUpdateAllFailedJobMarksUpdatingResultsFailed(t *testing.T) {
db := &database.DB{DB: gormDB}
require.NoError(t, db.AutoMigrate(&EnvironmentUpdateJob{}, &event.Event{}))
- svc := NewService(db, nil, nil, event.NewEventService(db, nil, nil), nil, nil, nil)
+ svc := NewService(db, nil, nil, event.NewEventService(db, nil, nil), nil, nil, nil, nil)
job := &EnvironmentUpdateJob{
Status: EnvironmentUpdateJobStatusRunning,
UserID: "user-1",
@@ -538,7 +539,7 @@ func TestUpdateAllFinalizesUpToDateManagerWithoutRestart(t *testing.T) {
db := &database.DB{DB: gormDB}
require.NoError(t, db.AutoMigrate(&EnvironmentUpdateJob{}, &event.Event{}))
- svc := NewService(db, nil, nil, event.NewEventService(db, nil, nil), nil, nil, nil)
+ svc := NewService(db, nil, nil, event.NewEventService(db, nil, nil), nil, nil, nil, nil)
job := &EnvironmentUpdateJob{
Status: EnvironmentUpdateJobStatusPendingRestart,
UserID: "user-1",
@@ -583,7 +584,7 @@ func TestUpdateAllStageChangesPersist(t *testing.T) {
db := &database.DB{DB: gormDB}
require.NoError(t, db.AutoMigrate(&EnvironmentUpdateJob{}))
- svc := NewService(db, nil, nil, nil, nil, nil, nil)
+ svc := NewService(db, nil, nil, nil, nil, nil, nil, nil)
job := &EnvironmentUpdateJob{
Status: EnvironmentUpdateJobStatusRunning,
Results: EnvironmentUpdateResults{
@@ -685,7 +686,7 @@ func TestResumeUpdateAllFinalizesManagerWithoutRerunningAgents(t *testing.T) {
// The reported version differs from ManagerVersionAtStart, so the manager upgrade
// is judged successful.
versionSvc := version.NewVersionService(nil, true, "v9.9.9-new", "", nil, nil, nil, nil)
- svc := NewService(db, nil, versionSvc, event.NewEventService(db, nil, nil), nil, nil, nil)
+ svc := NewService(db, nil, versionSvc, event.NewEventService(db, nil, nil), nil, nil, nil, nil)
harness := flowtest.New(t, nil)
require.NoError(t, svc.RegisterWorkflows(harness.Engine, nil, nil))
harness.Start(t)
diff --git a/backend/internal/system/service.go b/backend/internal/system/service.go
index aba63acff..8f2c6a9de 100644
--- a/backend/internal/system/service.go
+++ b/backend/internal/system/service.go
@@ -43,6 +43,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"
"github.com/getarcaneapp/arcane/backend/v2/internal/network"
"github.com/getarcaneapp/arcane/backend/v2/internal/project"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/registry"
"github.com/getarcaneapp/arcane/backend/v2/internal/role"
"github.com/getarcaneapp/arcane/backend/v2/internal/s3"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
@@ -51,6 +52,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/system/children/upgrade"
"github.com/getarcaneapp/arcane/backend/v2/internal/version"
"github.com/getarcaneapp/arcane/backend/v2/internal/volume"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler/flow"
@@ -86,6 +88,7 @@ func NewSystemService(
versionService *version.VersionService,
eventService *event.EventService,
projectService *project.ProjectService,
+ registryService *registry.ContainerRegistryService,
backupEngine *backup.Engine,
s3Destinations *s3.S3DestinationService,
recoveryKeys *backup.RecoveryKeyStore,
@@ -102,7 +105,7 @@ func NewSystemService(
WithTTL(dockerHostMemoryCacheTTL).
Build(),
prune: prune.NewService(cfg.GetLocation(), dockerService, activityService, imageUpdateService, volumeService, networkService),
- upgrade: upgrade.NewService(db, dockerService, versionService, eventService, settingsService, projectService, resolveUpgraderRuntimeOptions),
+ upgrade: upgrade.NewService(db, dockerService, versionService, eventService, settingsService, projectService, registryService, resolveUpgraderRuntimeOptions),
}
s.backup = systembackup.NewService(systembackup.Dependencies{
Store: s.backupStore(s3Destinations),
@@ -188,7 +191,10 @@ func (s *SystemService) StartAllContainers(ctx context.Context, environmentID st
ResourceName: "All containers",
StartMessage: "Starting all containers",
SuccessMessage: "Started all containers",
- ShouldStart: func(c mobycontainer.Summary) bool { return c.State != "running" },
+ ShouldStart: func(c mobycontainer.Summary) bool {
+ return (c.State == mobycontainer.StateExited || c.State == mobycontainer.StateCreated) &&
+ !strings.EqualFold(c.Labels[libarcane.InternalResourceLabel], "true")
+ },
Action: func(ctx context.Context, id string) error {
return s.containerService.StartContainer(ctx, id, usertypes.SystemUser)
},
@@ -202,7 +208,9 @@ func (s *SystemService) StartAllStoppedContainers(ctx context.Context, environme
ResourceName: "Stopped containers",
StartMessage: "Starting stopped containers",
SuccessMessage: "Started stopped containers",
- ShouldStart: func(c mobycontainer.Summary) bool { return c.State == "exited" },
+ ShouldStart: func(c mobycontainer.Summary) bool {
+ return c.State == mobycontainer.StateExited && !strings.EqualFold(c.Labels[libarcane.InternalResourceLabel], "true")
+ },
Action: func(ctx context.Context, id string) error {
return s.containerService.StartContainer(ctx, id, usertypes.SystemUser)
},
@@ -216,8 +224,9 @@ func (s *SystemService) StopAllContainers(ctx context.Context, environmentID str
ResourceName: "All containers",
StartMessage: "Stopping all containers",
SuccessMessage: "Stopped all containers",
- // Skip Arcane container
- ShouldStart: func(c mobycontainer.Summary) bool { return !labels.IsArcaneContainer(c.Labels) },
+ ShouldStart: func(c mobycontainer.Summary) bool {
+ return !labels.IsArcaneContainer(c.Labels) && !strings.EqualFold(c.Labels[libarcane.InternalResourceLabel], "true")
+ },
Action: func(ctx context.Context, id string) error {
return s.containerService.StopContainer(ctx, id, usertypes.SystemUser)
},
diff --git a/backend/internal/system/service_test.go b/backend/internal/system/service_test.go
index da0069e85..7935ca3cd 100644
--- a/backend/internal/system/service_test.go
+++ b/backend/internal/system/service_test.go
@@ -140,11 +140,11 @@ func TestListBackupHistoryClassifiesAndFiltersOrigins(t *testing.T) {
Format: volume.VolumeBackupFormatRustic,
}).Error)
db := &database.DB{DB: gormDB}
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
service := NewSystemService(
- db, nil, nil, nil, nil, nil, settingsService, nil, nil, nil, nil, nil,
+ db, nil, nil, nil, nil, nil, settingsService, nil, nil, nil, nil, nil, nil,
s3.NewS3DestinationService(db, func(context.Context, string) error { return nil }), nil, nil, &config.Config{},
)
@@ -220,7 +220,7 @@ func TestSystemBackupPoliciesRegisterIndependentJobs(t *testing.T) {
db := &database.DB{DB: gormDB}
recoveryKeys := backup.NewRecoveryKeyStore(db)
s3Destinations := s3.NewS3DestinationService(db, func(context.Context, string) error { return nil })
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
gate := newSystemBackupAdmissionGateForTest(t)
@@ -240,6 +240,7 @@ func TestSystemBackupPoliciesRegisterIndependentJobs(t *testing.T) {
nil,
nil,
nil,
+ nil,
backup.NewEngine(gate, nil),
s3Destinations,
recoveryKeys,
@@ -320,7 +321,7 @@ func TestSystemBackupPolicyRequiresConfiguredRecoveryKeyWhenEnabled(t *testing.T
require.NoError(t, gormDB.AutoMigrate(&SystemBackupPolicy{}, &backup.SystemBackupRecoveryConfig{}, &s3.S3Destination{}))
db := &database.DB{DB: gormDB}
service := NewSystemService(
- db, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ db, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
s3.NewS3DestinationService(db, func(context.Context, string) error { return nil }),
backup.NewRecoveryKeyStore(db), nil, &config.Config{DatabaseURL: "file:system-backup-key-required-test.db"},
)
diff --git a/backend/internal/template/service.go b/backend/internal/template/service.go
index 8aee091d4..8f4045e73 100644
--- a/backend/internal/template/service.go
+++ b/backend/internal/template/service.go
@@ -14,6 +14,7 @@ import (
"os"
"path/filepath"
"slices"
+ "strconv"
"strings"
"sync"
"sync/atomic"
@@ -80,6 +81,10 @@ const (
remoteCacheDuration = 5 * time.Minute
fsSyncInterval = 1 * time.Minute
+ maxDownloadSlugAttempts = 100
+ maxTemplateFileBytes = 4 << 20
+ maxTemplateRegistryBytes = 32 << 20
+
remoteIDPrefix = "remote"
)
@@ -765,10 +770,13 @@ func (s *TemplateService) FetchRaw(ctx context.Context, rawURL string) ([]byte,
return nil, fmt.Errorf("HTTP status %d for URL %s", resp.StatusCode, rawURL)
}
- body, err := io.ReadAll(resp.Body)
+ body, err := io.ReadAll(io.LimitReader(resp.Body, maxTemplateFileBytes+1))
if err != nil {
return nil, fmt.Errorf("failed to read response body from %s: %w", rawURL, err)
}
+ if len(body) > maxTemplateFileBytes {
+ return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("response from %s exceeds the %d MiB limit", rawURL, maxTemplateFileBytes>>20))
+ }
return body, nil
}
@@ -820,10 +828,13 @@ func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *Templ
return nil, fmt.Errorf("unexpected status %d", resp.StatusCode)
}
- body, err := io.ReadAll(resp.Body)
+ body, err := io.ReadAll(io.LimitReader(resp.Body, maxTemplateRegistryBytes+1))
if err != nil {
return nil, fmt.Errorf("read body: %w", err)
}
+ if len(body) > maxTemplateRegistryBytes {
+ return nil, fmt.Errorf("registry response exceeds the %d MiB limit", maxTemplateRegistryBytes>>20)
+ }
var regDTO tmpl.RemoteRegistry
if unmarshalErr := json.Unmarshal(body, &regDTO); unmarshalErr != nil {
@@ -958,11 +969,10 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
base = cmp.Or(projects.Slugify(remoteTemplate.ID[strings.LastIndex(remoteTemplate.ID, ":")+1:]), "template-"+uuid.New().String())
}
- dir, composePath, envPath, err := projects.EnsureTemplateDir(ctx, s.configuredTemplatesDirSetting(ctx), base)
+ templatesDir, err := s.getTemplatesDirectory(ctx)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("ensure templates dir: %w", err)
}
- srcDesc := fmt.Sprintf("Imported from %s/compose.yaml", dir)
composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
if err != nil {
@@ -974,10 +984,14 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
var resultTemplate *ComposeTemplate
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- var existing ComposeTemplate
- findErr := tx.Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, base).First(&existing).Error
- if findErr != nil && !errors.Is(findErr, gorm.ErrRecordNotFound) {
- return fmt.Errorf("failed to check existing template: %w", findErr)
+ slug, existing, targetErr := resolveDownloadTarget(tx, templatesDir, base, strings.TrimSpace(kit.FromPtr(kit.FromPtr(remoteTemplate.Metadata).RemoteURL)))
+ if targetErr != nil {
+ return targetErr
+ }
+
+ dir, composePath, envPath, ensureErr := projects.EnsureTemplateDir(ctx, s.configuredTemplatesDirSetting(ctx), slug)
+ if ensureErr != nil {
+ return ensureErr
}
envPtr, writeErr := projects.WriteTemplateFiles(composePath, envPath, composeContent, envContent)
@@ -985,21 +999,21 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
return writeErr
}
- if findErr == nil {
+ if existing != nil {
existing.Content = composeContent
existing.EnvContent = envPtr
existing.Metadata = cloneTemplateMetadata(remoteTemplate.Metadata)
- if saveErr := tx.Save(&existing).Error; saveErr != nil {
+ if saveErr := tx.Save(existing).Error; saveErr != nil {
return fmt.Errorf("failed to update existing local template: %w", saveErr)
}
- resultTemplate = &existing
+ resultTemplate = existing
return nil
}
localTemplate := &ComposeTemplate{
ID: uuid.New().String(),
- Name: base,
- Description: srcDesc,
+ Name: slug,
+ Description: fmt.Sprintf("Imported from %s/compose.yaml", dir),
Content: composeContent,
EnvContent: envPtr,
IsCustom: true,
@@ -1017,6 +1031,53 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
return resultTemplate, nil
}
+func resolveDownloadTarget(tx *gorm.DB, templatesDir, base, remoteURL string) (string, *ComposeTemplate, error) {
+ if remoteURL != "" {
+ prefix := "Imported from " + filepath.Join(templatesDir, base)
+ var owned []ComposeTemplate
+ if findErr := tx.Where("is_remote = ? AND registry_id IS NULL AND description LIKE ? AND meta_remote_url = ?", false, prefix+"%", remoteURL).
+ Order("created_at").
+ Find(&owned).Error; findErr != nil {
+ return "", nil, fmt.Errorf("failed to check previously downloaded template: %w", findErr)
+ }
+ for i := range owned {
+ rest, hasPrefix := strings.CutPrefix(owned[i].Description, prefix)
+ suffix, hasSuffix := strings.CutSuffix(rest, "/compose.yaml")
+ _, numberErr := strconv.Atoi(strings.TrimPrefix(suffix, "-"))
+ if hasPrefix && hasSuffix && (suffix == "" || (strings.HasPrefix(suffix, "-") && numberErr == nil)) {
+ return base + suffix, &owned[i], nil
+ }
+ }
+ }
+ for attempt := 1; attempt <= maxDownloadSlugAttempts; attempt++ {
+ slug := kit.Ternary(attempt == 1, base, fmt.Sprintf("%s-%d", base, attempt))
+ dir := filepath.Join(templatesDir, slug)
+ srcDesc := fmt.Sprintf("Imported from %s/compose.yaml", dir)
+
+ var rows []ComposeTemplate
+ if findErr := tx.Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, slug).Find(&rows).Error; findErr != nil {
+ return "", nil, fmt.Errorf("failed to check existing template: %w", findErr)
+ }
+ if owned := slices.IndexFunc(rows, func(row ComposeTemplate) bool {
+ return remoteURL != "" && row.Description == srcDesc && strings.TrimSpace(kit.FromPtr(kit.FromPtr(row.Metadata).RemoteURL)) == remoteURL
+ }); owned >= 0 {
+ return slug, &rows[owned], nil
+ }
+ if len(rows) > 0 {
+ continue
+ }
+
+ _, statErr := os.Lstat(dir)
+ switch {
+ case errors.Is(statErr, os.ErrNotExist):
+ return slug, nil, nil
+ case statErr != nil:
+ return "", nil, fmt.Errorf("failed to check template directory %s: %w", dir, statErr)
+ }
+ }
+ return "template-" + uuid.New().String(), nil, nil
+}
+
func cloneTemplateMetadata(meta *ComposeTemplateMetadata) *ComposeTemplateMetadata {
if meta == nil {
return nil
diff --git a/backend/internal/template/service_test.go b/backend/internal/template/service_test.go
index 91e9cf45f..7148ff11b 100644
--- a/backend/internal/template/service_test.go
+++ b/backend/internal/template/service_test.go
@@ -20,6 +20,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
@@ -246,6 +247,87 @@ func TestDownloadTemplate_PreservesIconURL(t *testing.T) {
}
}
+func TestDownloadTemplate_DoesNotOverwriteUnownedTemplate(t *testing.T) {
+ tempDir := t.TempDir()
+ setTestWorkingDir(t, tempDir)
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/compose.yaml" {
+ http.NotFound(w, r)
+ return
+ }
+ _, _ = w.Write([]byte("services:\n app:\n image: nginx:alpine\n"))
+ }))
+ defer server.Close()
+
+ client, lookupIP, baseURL := makePublicTestClient(t, server)
+
+ templatesDir := filepath.Join(tempDir, "templates")
+ settingsSvc := minimalSettingsServiceForTest(t)
+ require.NoError(t, settingsSvc.UpdateSetting(t.Context(), "templatesDirectory", templatesDir))
+
+ service := &TemplateService{
+ db: setupTemplateServiceTestDB(t),
+ httpClient: client,
+ lookupIP: lookupIP,
+ settingsService: settingsSvc,
+ registryFetchMeta: make(map[string]*registryFetchMeta),
+ }
+
+ customCompose := "services:\n custom:\n image: busybox\n"
+ customComposePath := filepath.Join(templatesDir, "nginx", "compose.yaml")
+ require.NoError(t, os.MkdirAll(filepath.Dir(customComposePath), 0o755))
+ require.NoError(t, os.WriteFile(customComposePath, []byte(customCompose), 0o600))
+ custom := &ComposeTemplate{
+ ID: "custom-nginx",
+ Name: "nginx",
+ Description: "Imported from " + customComposePath,
+ Content: customCompose,
+ IsCustom: true,
+ }
+ require.NoError(t, service.db.WithContext(t.Context()).Create(custom).Error)
+
+ remoteTemplate := &ComposeTemplate{
+ ID: "remote:reg-1:nginx",
+ Name: "nginx",
+ IsRemote: true,
+ Metadata: &ComposeTemplateMetadata{
+ RemoteURL: new(baseURL + "/compose.yaml"),
+ },
+ }
+
+ downloaded, err := service.DownloadTemplate(t.Context(), remoteTemplate)
+ require.NoError(t, err)
+ require.NotEqual(t, custom.ID, downloaded.ID)
+ require.Equal(t, "nginx-2", downloaded.Name)
+
+ onDisk, err := os.ReadFile(customComposePath)
+ require.NoError(t, err)
+ require.Equal(t, customCompose, string(onDisk))
+
+ var stored ComposeTemplate
+ require.NoError(t, service.db.WithContext(t.Context()).First(&stored, "id = ?", custom.ID).Error)
+ require.Equal(t, customCompose, stored.Content)
+
+ redownloaded, err := service.DownloadTemplate(t.Context(), remoteTemplate)
+ require.NoError(t, err)
+ require.Equal(t, downloaded.ID, redownloaded.ID)
+
+ movedDir := filepath.Join(templatesDir, "nginx-3")
+ require.NoError(t, os.Rename(filepath.Join(templatesDir, "nginx-2"), movedDir))
+ require.NoError(t, service.db.WithContext(t.Context()).Model(&ComposeTemplate{}).Where("id = ?", downloaded.ID).Updates(map[string]any{
+ "name": "nginx-3",
+ "description": "Imported from " + filepath.Join(movedDir, "compose.yaml"),
+ }).Error)
+
+ movedDownload, err := service.DownloadTemplate(t.Context(), remoteTemplate)
+ require.NoError(t, err)
+ require.Equal(t, downloaded.ID, movedDownload.ID)
+ require.Equal(t, "nginx-3", movedDownload.Name)
+ require.NoDirExists(t, filepath.Join(templatesDir, "nginx-2"))
+ require.FileExists(t, filepath.Join(movedDir, "compose.yaml"))
+}
+
func TestGetAllTemplatesPaginated_FiltersByType(t *testing.T) {
tempDir := t.TempDir()
setTestWorkingDir(t, tempDir)
@@ -437,7 +519,7 @@ func minimalSettingsServiceForTest(t *testing.T) *settings.SettingsService {
func newSettingsServiceForTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/updater/service_test.go b/backend/internal/updater/service_test.go
index 717505fa9..047586465 100644
--- a/backend/internal/updater/service_test.go
+++ b/backend/internal/updater/service_test.go
@@ -249,7 +249,7 @@ func TestUpdaterService_ApplyPendingNoRecords(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
require.NoError(t, db.AutoMigrate(&notification.NotificationSettings{}))
- settingsService, err := settings.NewSettingsService(ctx, db)
+ settingsService, err := settings.NewSettingsService(ctx, db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(ctx))) })
notif := notification.NewNotificationService(db, nil, nil, nil, nil)
@@ -474,7 +474,7 @@ func TestUpdaterService_PullImageAdapter(t *testing.T) {
t.Run("delegates to Arcane image puller", func(t *testing.T) {
db := setupProjectTestDB(t)
require.NoError(t, db.AutoMigrate(&registry.ContainerRegistry{}))
- settingsService, err := settings.NewSettingsService(ctx, db)
+ settingsService, err := settings.NewSettingsService(ctx, db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(ctx))) })
server := newImagePullServerWithObserver(t, nil, nil)
@@ -517,7 +517,7 @@ func TestUpdaterService_PullImageAdapter(t *testing.T) {
gotAuth = authHeader
}
})
- settingsService, err := settings.NewSettingsService(ctx, db)
+ settingsService, err := settings.NewSettingsService(ctx, db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(ctx))) })
dockerSvc := docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server))
@@ -1783,7 +1783,7 @@ func TestSingleUpdatePersistsSuccessfulActivity(t *testing.T) {
defer server.Close()
activityService := activity.NewActivityService(db, nil)
dockerSvc := (&docker.DockerClientService{}).WithClient(newTestDockerClient(t, server))
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
harness := flowtest.New(t, activityService)
@@ -1859,7 +1859,7 @@ func TestUpdaterService_AutoUpdateDeferral(t *testing.T) {
HasUpdate: true,
},
}).Error)
- settingsService, err := settings.NewSettingsService(ctx, db)
+ settingsService, err := settings.NewSettingsService(ctx, db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(ctx))) })
require.NoError(t, settingsService.SetIntSetting(ctx, "autoUpdateDelay", 24))
diff --git a/backend/internal/variable/service_test.go b/backend/internal/variable/service_test.go
index 918c52201..851badb7a 100644
--- a/backend/internal/variable/service_test.go
+++ b/backend/internal/variable/service_test.go
@@ -22,6 +22,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/kv"
@@ -32,7 +33,7 @@ import (
func newSettingsServiceForVariableTestInternal(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/version/service.go b/backend/internal/version/service.go
index 740b39da8..010875711 100644
--- a/backend/internal/version/service.go
+++ b/backend/internal/version/service.go
@@ -89,19 +89,26 @@ func NewVersionService(
streamHub: agg.NewHub[version.StreamEvent](),
currentImage: hot.NewHotCache[struct{}, currentImageInfo](hot.LRU, 1).Build(),
}
- loader := func(_ []struct{}) (map[struct{}]latestRelease, error) {
- ctx, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout) //nolint:forbidigo // Cache revalidation runs independently of request cancellation.
- defer cancel()
- release, err := service.fetchLatestRelease(ctx)
- if err != nil {
- return nil, err
+ loader := func(cacheFailure bool) func(_ []struct{}) (map[struct{}]latestRelease, error) {
+ return func(_ []struct{}) (map[struct{}]latestRelease, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), defaultRequestTimeout) //nolint:forbidigo // Cache revalidation runs independently of request cancellation.
+ defer cancel()
+ release, err := service.fetchLatestRelease(ctx)
+ switch {
+ case err != nil && cacheFailure:
+ slog.WarnContext(ctx, "Failed to fetch latest Arcane release; skipping update checks until the cache expires", "error", err)
+ return map[struct{}]latestRelease{{}: {}}, nil
+ case err != nil:
+ return nil, err
+ default:
+ return map[struct{}]latestRelease{{}: release}, nil
+ }
}
- return map[struct{}]latestRelease{{}: release}, nil
}
service.cache = hot.NewHotCache[struct{}, latestRelease](hot.LRU, 1).
WithTTL(versionTTL).
- WithLoaders(loader).
- WithRevalidation(24*time.Hour, loader).
+ WithLoaders(loader(true)).
+ WithRevalidation(24*time.Hour, loader(false)).
WithRevalidationErrorPolicy(hot.KeepOnError).
Build()
return service
diff --git a/backend/internal/vulnerability/children/scan/children/trivy/service.go b/backend/internal/vulnerability/children/scan/children/trivy/service.go
index 140793645..e953de560 100644
--- a/backend/internal/vulnerability/children/scan/children/trivy/service.go
+++ b/backend/internal/vulnerability/children/scan/children/trivy/service.go
@@ -10,6 +10,7 @@ import (
"log/slog"
"os"
"slices"
+ "strconv"
"strings"
"sync"
"time"
@@ -44,8 +45,11 @@ import (
const (
trivyCPUCapabilitiesCacheTTL = time.Hour
trivyCPUCapabilitiesLookupTimeout = 5 * time.Second
+ trivyVersionCacheTTL = 24 * time.Hour
+ trivyVersionCacheKey = "trivy:version:v1"
trivyCacheVolumeName = "arcane-trivy-cache"
+ trivyBatchContainerLabel = "com.getarcaneapp.trivy.batch"
trivyCacheSlotRootDir = vuln.CacheMountTarget + "/arcane-scan-slots"
defaultTrivyCPULimitCores = 1.0
defaultTrivyMemoryLimitMB int64 = 0
@@ -100,7 +104,10 @@ func (s *Service) AcquireSlot(ctx context.Context, imageID string, wait bool) (s
if !wait {
return 0, nil, nil
}
- unlock = s.scanLocks.Lock(imageID)
+ var lockErr error
+ if unlock, lockErr = s.scanLocks.LockContext(ctx, imageID); lockErr != nil {
+ return 0, nil, lockErr
+ }
}
}
defer func() {
@@ -156,7 +163,7 @@ func (s *Service) ConcurrentScanContainers() int {
// SetupBatchContainers starts long-running scanner containers that scheduled scans exec into,
// avoiding a container lifecycle per image.
-func (s *Service) SetupBatchContainers(ctx context.Context, count int) ([]string, map[string][]byte, func(), error) {
+func (s *Service) SetupBatchContainers(ctx context.Context, count int, keep []string) ([]string, map[string][]byte, func(), error) {
if err := s.settingsService.RequireFeature(ctx, features.VulnerabilityManagement); err != nil {
return nil, nil, nil, err
}
@@ -165,6 +172,20 @@ func (s *Service) SetupBatchContainers(ctx context.Context, count int) ([]string
return nil, nil, nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
+ leftovers, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{
+ All: true,
+ Filters: make(client.Filters).Add("label", trivyBatchContainerLabel+"=true"),
+ })
+ if err != nil {
+ return nil, nil, nil, fmt.Errorf("failed to list leftover batch trivy containers: %w", err)
+ }
+ for _, leftover := range leftovers.Items {
+ if slices.Contains(keep, leftover.ID) {
+ continue
+ }
+ vuln.RemoveContainer(ctx, dockerClient, leftover.ID, "leftover batch trivy container")
+ }
+
scannerImage, err := s.EnsureImage(ctx)
if err != nil {
return nil, nil, nil, fmt.Errorf("trivy scanner not available: %w", err)
@@ -192,6 +213,7 @@ func (s *Service) SetupBatchContainers(ctx context.Context, count int) ([]string
Env: slices.Concat(runtimeOptions.ContainerEnv, kit.Ternary(files[vuln.RegistryConfigFile] != nil, []string{"DOCKER_CONFIG=" + vuln.RegistryConfigDir}, nil)),
Labels: map[string]string{
libarcane.InternalResourceLabel: "true",
+ trivyBatchContainerLabel: "true",
},
}
hostConfig := vuln.BuildBatchHostConfig(
@@ -222,6 +244,27 @@ func (s *Service) SetupBatchContainers(ctx context.Context, count int) ([]string
containerIDs = append(containerIDs, containerID)
}
+ retainedSlots := func() int {
+ s.trivyScanMu.Lock()
+ defer s.trivyScanMu.Unlock()
+ if s.trivyScanSlots != nil && len(s.trivyScanSlots) != cap(s.trivyScanSlots) {
+ return max(count, cap(s.trivyScanSlots), 1)
+ }
+ return max(count, 1)
+ }()
+ if _, pruneErr := docker.ExecInContainer(ctx, dockerClient, containerIDs[0], client.ExecCreateOptions{
+ Cmd: []string{
+ "sh",
+ "-c",
+ `for dir in "$1"/slot-*; do [ -d "$dir" ] && [ "${dir##*/slot-}" -ge "$2" ] 2>/dev/null && rm -rf "$dir"; done; exit 0`,
+ "sh",
+ trivyCacheSlotRootDir,
+ strconv.Itoa(retainedSlots),
+ },
+ }, io.Discard, io.Discard); pruneErr != nil {
+ slog.DebugContext(ctx, "failed to remove unused trivy slot caches", "error", pruneErr)
+ }
+
return containerIDs, files, cleanup, nil
}
@@ -389,6 +432,19 @@ func (s *Service) Version(ctx context.Context) string {
return ""
}
+ scannerInspect, scannerInspectErr := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ImageInspectResult, error) {
+ return cli.ImageInspect(ctx, scannerImage)
+ })
+ if scannerInspectErr == nil && scannerInspect.ID != "" {
+ if raw, found, cacheErr := s.kvService.Get(ctx, trivyVersionCacheKey); cacheErr == nil && found {
+ var cached trivyVersionCache
+ if unmarshalErr := json.Unmarshal([]byte(raw), &cached); unmarshalErr == nil &&
+ cached.ScannerImageID == scannerInspect.ID && cached.Version != "" && time.Since(cached.FetchedAt) < trivyVersionCacheTTL {
+ return cached.Version
+ }
+ }
+ }
+
resp, err := s.dockerService.Call(ctx, func(ctx context.Context, cli *client.Client) (client.ContainerCreateResult, error) {
return cli.ContainerCreate(ctx, client.ContainerCreateOptions{
Config: &container.Config{
@@ -472,7 +528,23 @@ func (s *Service) Version(ctx context.Context) string {
return ""
}
- return vuln.ParseVersion(vuln.ReadTempFileExcerpt(stdoutFile))
+ version := vuln.ParseVersion(vuln.ReadTempFileExcerpt(stdoutFile))
+ if version != "" && scannerInspectErr == nil && scannerInspect.ID != "" {
+ payload, marshalErr := json.Marshal(trivyVersionCache{
+ ScannerImageID: scannerInspect.ID,
+ Version: version,
+ FetchedAt: time.Now(),
+ })
+ switch {
+ case marshalErr != nil:
+ slog.WarnContext(ctx, "failed to encode Trivy version cache", "error", marshalErr)
+ default:
+ if setErr := s.kvService.Set(ctx, trivyVersionCacheKey, string(payload)); setErr != nil {
+ slog.WarnContext(ctx, "failed to cache Trivy version", "error", setErr)
+ }
+ }
+ }
+ return version
}
func (s *Service) resolveTrivyRuntimeOptions(ctx context.Context, dockerClient *client.Client) (vuln.RuntimeOptions, error) {
@@ -959,6 +1031,12 @@ func (s *Service) Scan(ctx context.Context, scannerImage, imageName, imageID str
}, outputPath, imageName, imageID, "container", s.Version)
}
+type trivyVersionCache struct {
+ ScannerImageID string `json:"scannerImageId"`
+ Version string `json:"version"`
+ FetchedAt time.Time `json:"fetchedAt"`
+}
+
type trivyCPUCapabilities struct {
Quota bool `json:"quota"`
CPUSet bool `json:"cpuSet"`
diff --git a/backend/internal/vulnerability/children/scan/children/trivy/service_test.go b/backend/internal/vulnerability/children/scan/children/trivy/service_test.go
index 9ea0b1a12..5be9a508c 100644
--- a/backend/internal/vulnerability/children/scan/children/trivy/service_test.go
+++ b/backend/internal/vulnerability/children/scan/children/trivy/service_test.go
@@ -32,7 +32,7 @@ func featureSettings(t *testing.T) (*settings.SettingsService, *database.DB) {
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &kv.KVEntry{}))
db := &database.DB{DB: gdb}
- svc, err := settings.NewSettingsService(t.Context(), db)
+ svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
@@ -499,6 +499,6 @@ func TestVulnerabilityFeatureDisabledRejectsBatchContainers(t *testing.T) {
svc := NewService(&config.Config{}, docker.NewDockerClientService(t.Context(), nil, nil, nil), settingsSvc, kv.NewKVService(db), nil, nil, nil)
require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), features.VulnerabilityManagementSettingKey, false))
- _, _, _, err := svc.SetupBatchContainers(t.Context(), 1)
+ _, _, _, err := svc.SetupBatchContainers(t.Context(), 1, nil)
require.ErrorIs(t, err, common.ErrFeatureDisabled)
}
diff --git a/backend/internal/vulnerability/children/scan/service.go b/backend/internal/vulnerability/children/scan/service.go
index 06030c735..79d8694fd 100644
--- a/backend/internal/vulnerability/children/scan/service.go
+++ b/backend/internal/vulnerability/children/scan/service.go
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"log/slog"
+ "maps"
"slices"
"strings"
"sync"
@@ -49,8 +50,8 @@ var scheduledScanUser = usertypes.Actor{Username: "System"}
// Records updates scan records, whose model the vulnerability domain owns.
type Records struct {
- MarkScanning func(ctx context.Context, imageID string) error
- MarkFailed func(ctx context.Context, imageID, message string, duration int64) error
+ MarkStatus func(ctx context.Context, imageID string, status vulnerability.ScanStatus) (bool, error)
+ MarkFailed func(ctx context.Context, imageID, message string, duration int64) (bool, error)
SetImageName func(ctx context.Context, imageID, imageName string) error
}
@@ -68,6 +69,7 @@ type Dependencies struct {
Notifications *notification.NotificationService
Activity *activity.ActivityService
SaveResult func(ctx context.Context, result *vulnerability.ScanResult) error
+ SaveScheduledResult func(ctx context.Context, result *vulnerability.ScanResult) error
EnsureSummary func(result *vulnerability.ScanResult) *vulnerability.SeveritySummary
FilterIgnored func(ctx context.Context, envID, imageID string, vulns []vulnerability.Vulnerability) ([]vulnerability.Vulnerability, error)
}
@@ -83,11 +85,13 @@ type Service struct {
notificationService *notification.NotificationService
activityService *activity.ActivityService
saveResult func(ctx context.Context, result *vulnerability.ScanResult) error
+ saveScheduledResult func(ctx context.Context, result *vulnerability.ScanResult) error
ensureSummary func(result *vulnerability.ScanResult) *vulnerability.SeveritySummary
filterIgnored func(ctx context.Context, envID, imageID string, vulns []vulnerability.Vulnerability) ([]vulnerability.Vulnerability, error)
scanPhases sync.Map // map[string]vulnerability.ScanPhase
poolMu sync.Mutex
pool *scanPool
+ liveContainers map[string]struct{}
}
type (
@@ -132,8 +136,10 @@ func NewService(deps Dependencies) *Service {
notificationService: deps.Notifications,
activityService: deps.Activity,
saveResult: deps.SaveResult,
+ saveScheduledResult: deps.SaveScheduledResult,
ensureSummary: deps.EnsureSummary,
filterIgnored: deps.FilterIgnored,
+ liveContainers: map[string]struct{}{},
}
return s
}
@@ -222,7 +228,9 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
ScanPhase: s.resolveScanPhase(imageID, status),
Summary: &vulnerability.SeveritySummary{},
}
- if saveErr := s.saveResult(scanCtx, pendingResult); saveErr != nil {
+ if saveErr := s.markOrSaveResult(scanCtx, pendingResult, func(ctx context.Context) (bool, error) {
+ return s.records.MarkStatus(ctx, imageID, status)
+ }); saveErr != nil {
slog.WarnContext(scanCtx, "failed to save pending scan result", "error", saveErr, "imageId", imageID, "imageName", imageName)
}
@@ -233,7 +241,7 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
}
if releaseSlot != nil {
defer releaseSlot()
- if updateErr := s.records.MarkScanning(scanCtx, imageID); updateErr != nil {
+ if _, updateErr := s.records.MarkStatus(scanCtx, imageID, vulnerability.ScanStatusScanning); updateErr != nil {
slog.WarnContext(scanCtx, "failed to mark queued scan as running", "imageId", imageID, "error", updateErr)
}
}
@@ -242,7 +250,7 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
fail := func(message string, duration int64) {
s.setScanPhase(imageID, vulnerability.ScanPhaseStoringResults)
s.updateVulnerabilityScanActivity(scanCtx, activityID, vulnerability.ScanPhaseStoringResults, 90, "Storing failed scan result")
- if saveErr := s.saveResult(scanCtx, &vulnerability.ScanResult{
+ if saveErr := s.markOrSaveResult(context.WithoutCancel(scanCtx), &vulnerability.ScanResult{
ImageID: imageID,
ImageName: imageName,
ScanTime: time.Now(),
@@ -250,6 +258,8 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
ActivityID: activityRef,
Error: message,
Duration: duration,
+ }, func(ctx context.Context) (bool, error) {
+ return s.records.MarkFailed(ctx, imageID, message, duration)
}); saveErr != nil {
slog.WarnContext(scanCtx, "failed to save failed scan result", "error", saveErr)
}
@@ -268,6 +278,10 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
return
}
+ if featureErr := s.settingsService.RequireFeature(scanCtx, features.VulnerabilityManagement); featureErr != nil {
+ fail(featureErr.Error(), 0)
+ return
+ }
s.setScanPhase(imageID, vulnerability.ScanPhaseScanningImage)
s.updateVulnerabilityScanActivity(scanCtx, activityID, vulnerability.ScanPhaseScanningImage, 45, "Scanning image for vulnerabilities")
startTime := time.Now()
@@ -279,6 +293,10 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
return
}
+ if featureErr := s.settingsService.RequireFeature(scanCtx, features.VulnerabilityManagement); featureErr != nil {
+ fail(featureErr.Error(), duration)
+ return
+ }
result := &vulnerability.ScanResult{ //exhaustruct:enforce
ImageID: scanned.ImageID,
ImageName: scanned.ImageName,
@@ -308,6 +326,14 @@ func (s *Service) ScanImage(ctx context.Context, envID, imageID string, user use
return pendingResult, nil
}
+func (s *Service) markOrSaveResult(ctx context.Context, result *vulnerability.ScanResult, mark func(context.Context) (bool, error)) error {
+ marked, err := mark(ctx)
+ if err != nil || marked {
+ return err
+ }
+ return s.saveResult(ctx, result)
+}
+
// markStale fails a pending or scanning scan that outlived scanStaleTimeout
// and returns the failure message and duration.
func (s *Service) markStale(ctx context.Context, imageID string, status vulnerability.ScanStatus, scanTime time.Time) (string, int64, bool) {
@@ -321,7 +347,7 @@ func (s *Service) markStale(ctx context.Context, imageID string, status vulnerab
errMsg := "Scan timed out or was interrupted. Please retry."
duration := time.Since(scanTime).Milliseconds()
s.scanPhases.Delete(imageID)
- if err := s.records.MarkFailed(ctx, imageID, errMsg, duration); err != nil {
+ if _, err := s.records.MarkFailed(ctx, imageID, errMsg, duration); err != nil {
slog.WarnContext(ctx, "failed to mark stale scan as failed", "error", err, "scanId", imageID)
}
return errMsg, duration, true
@@ -484,7 +510,7 @@ func (s *Service) joinPool(ctx context.Context) (*scanPool, func(), error) {
if s.pool == nil {
// Setup stays cancelable and bounded, since later scans wait on poolMu; removing the containers detaches on its own.
setupCtx, cancelSetup := context.WithTimeout(ctx, scanPoolSetupTimeout)
- containerIDs, files, cleanup, err := s.trivy.SetupBatchContainers(setupCtx, s.trivy.ConcurrentScanContainers())
+ containerIDs, files, cleanup, err := s.trivy.SetupBatchContainers(setupCtx, s.trivy.ConcurrentScanContainers(), slices.Collect(maps.Keys(s.liveContainers)))
cancelSetup()
if err != nil {
s.poolMu.Unlock()
@@ -493,10 +519,18 @@ func (s *Service) joinPool(ctx context.Context) (*scanPool, func(), error) {
s.pool = &scanPool{
containers: make(chan string, len(containerIDs)),
files: files,
- cleanup: cleanup,
- retired: make(chan struct{}),
+ cleanup: func() {
+ cleanup()
+ s.poolMu.Lock()
+ for _, containerID := range containerIDs {
+ delete(s.liveContainers, containerID)
+ }
+ s.poolMu.Unlock()
+ },
+ retired: make(chan struct{}),
}
for _, containerID := range containerIDs {
+ s.liveContainers[containerID] = struct{}{}
s.pool.containers <- containerID
}
}
@@ -537,7 +571,7 @@ func (s *Service) ScanTarget(ctx context.Context, envID string, target Target) (
slog.InfoContext(ctx, "scheduled vulnerability scan: scanning image", "image", target.ImageName, "imageId", target.ImageID)
startTime := time.Now()
- slotID, releaseSlot, err := s.trivy.AcquireSlot(ctx, "", true)
+ slotID, releaseSlot, err := s.trivy.AcquireSlot(ctx, target.ImageID, true)
if err != nil {
return Fixable{}, err
}
@@ -581,13 +615,15 @@ func (s *Service) ScanTarget(ctx context.Context, envID string, target Target) (
scanned, err := s.trivy.ExecScan(ctx, containerID, target.ImageName, target.ImageID, target.ScannerVersion, slotID, pool.files)
duration := time.Since(startTime).Milliseconds()
if err != nil {
- if saveErr := s.saveResult(ctx, &vulnerability.ScanResult{
+ if saveErr := s.markOrSaveResult(context.WithoutCancel(ctx), &vulnerability.ScanResult{
ImageID: target.ImageID,
ImageName: target.ImageName,
ScanTime: time.Now(),
Status: vulnerability.ScanStatusFailed,
Error: err.Error(),
Duration: duration,
+ }, func(ctx context.Context) (bool, error) {
+ return s.records.MarkFailed(ctx, target.ImageID, err.Error(), duration)
}); saveErr != nil {
slog.WarnContext(ctx, "failed to save failed scan result", "error", saveErr)
}
@@ -609,8 +645,8 @@ func (s *Service) ScanTarget(ctx context.Context, envID string, target Target) (
HasReport: scanned.HasReport,
Insights: scanned.Insights,
}
- if saveErr := s.saveResult(ctx, result); saveErr != nil {
- slog.WarnContext(ctx, "failed to save scan result", "error", saveErr)
+ if saveErr := s.saveScheduledResult(ctx, result); saveErr != nil {
+ return Fixable{}, common.Classify(common.ErrUnavailable, fmt.Errorf("save scan result for %s: %w", target.ImageName, saveErr))
}
s.logScanEvent(ctx, event.EventTypeImageVulnerabilityScan, "scheduled_vulnerability_scan", envID, target.ImageID, target.ImageName, scheduledScanUser, "")
diff --git a/backend/internal/vulnerability/children/scan/service_test.go b/backend/internal/vulnerability/children/scan/service_test.go
index 2325d169b..810b4f6db 100644
--- a/backend/internal/vulnerability/children/scan/service_test.go
+++ b/backend/internal/vulnerability/children/scan/service_test.go
@@ -12,6 +12,7 @@ import (
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/notification"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
@@ -23,7 +24,7 @@ func featureSettings(t *testing.T) (*settings.SettingsService, *database.DB) {
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}))
db := &database.DB{DB: gdb}
- svc, err := settings.NewSettingsService(t.Context(), db)
+ svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/internal/vulnerability/children/store/service.go b/backend/internal/vulnerability/children/store/service.go
index 59374fe8c..bee76a058 100644
--- a/backend/internal/vulnerability/children/store/service.go
+++ b/backend/internal/vulnerability/children/store/service.go
@@ -54,6 +54,7 @@ type Records struct {
SaveStatus func(ctx context.Context, result *vulnerability.ScanResult, summary *vulnerability.SeveritySummary, errMessage string) error
Delete func(ctx context.Context, imageIDs []string) error
DeleteReports func(ctx context.Context, imageIDs []string) error
+ DeleteIgnores func(ctx context.Context, imageIDs []string) error
IDsExcept func(ctx context.Context, keepIDs []string) ([]string, error)
DeleteExcept func(ctx context.Context, keepIDs []string) (int64, error)
EachMissingItems func(ctx context.Context, batchSize int, fn func(imageID, vulnerabilitiesJSON string)) error
@@ -113,6 +114,9 @@ func (s *Service) deleteScanChildRows(ctx context.Context, imageIDs []string) {
if err := s.records.DeleteItems(s.db.WithContext(ctx), imageIDs); err != nil {
slog.WarnContext(ctx, "failed to delete stored vulnerability scan items", "error", err)
}
+ if err := s.records.DeleteIgnores(ctx, imageIDs); err != nil {
+ slog.WarnContext(ctx, "failed to delete vulnerability ignores for removed images", "error", err)
+ }
}
// BackfillScanItems populates vulnerability_scan_items for completed scans
@@ -341,6 +345,8 @@ func (s *Service) saveScanResultStatusFallback(ctx context.Context, result *vuln
return
}
+ ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
+ defer cancel()
errMsg := cmp.Or(strings.TrimSpace(result.Error), kit.Ternary(originalErr != nil, fmt.Sprintf("failed to persist full scan result: %v", originalErr), ""))
if err := s.records.SaveStatus(ctx, result, cmp.Or(result.Summary, &vulnerability.SeveritySummary{}), errMsg); err != nil {
slog.WarnContext(ctx,
diff --git a/backend/internal/vulnerability/service.go b/backend/internal/vulnerability/service.go
index 13ce3b9bf..cf444fd19 100644
--- a/backend/internal/vulnerability/service.go
+++ b/backend/internal/vulnerability/service.go
@@ -120,6 +120,13 @@ func NewVulnerabilityService(
DeleteReports: func(ctx context.Context, imageIDs []string) error {
return s.db.WithContext(ctx).Where("image_id IN ?", imageIDs).Delete(&VulnerabilityReportRecord{}).Error
},
+ DeleteIgnores: func(ctx context.Context, imageIDs []string) error {
+ result := s.db.WithContext(ctx).Where("environment_id = ? AND image_id IN ?", types.LocalDockerEnvironmentID, imageIDs).Delete(&VulnerabilityIgnore{})
+ if result.Error == nil && result.RowsAffected > 0 {
+ s.query.InvalidateRiskOverview()
+ }
+ return result.Error
+ },
IDsExcept: func(ctx context.Context, keepIDs []string) ([]string, error) {
scope := s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{})
if len(keepIDs) > 0 {
@@ -266,15 +273,21 @@ func NewVulnerabilityService(
scan: scan.NewService(scan.Dependencies{
DB: db,
Records: scan.Records{
- MarkScanning: func(ctx context.Context, imageID string) error {
- return s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Update("status", ScanStatusScanning).Error
+ MarkStatus: func(ctx context.Context, imageID string, status vulnerability.ScanStatus) (bool, error) {
+ result := s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Updates(map[string]any{
+ "status": string(status),
+ "scan_time": time.Now(),
+ "error": nil,
+ })
+ return result.RowsAffected > 0, result.Error
},
- MarkFailed: func(ctx context.Context, imageID, message string, duration int64) error {
- return s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Updates(map[string]any{
+ MarkFailed: func(ctx context.Context, imageID, message string, duration int64) (bool, error) {
+ result := s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Updates(map[string]any{
"status": ScanStatusFailed,
"error": message,
"duration": duration,
- }).Error
+ })
+ return result.RowsAffected > 0, result.Error
},
SetImageName: func(ctx context.Context, imageID, imageName string) error {
return s.db.WithContext(ctx).Model(&VulnerabilityScanRecord{}).Where("id = ?", imageID).Update("image_name", imageName).Error
@@ -299,6 +312,9 @@ func NewVulnerabilityService(
s.query.InvalidateRiskOverview()
return nil
},
+ SaveScheduledResult: func(ctx context.Context, result *vulnerability.ScanResult) error {
+ return s.store.SaveResult(ctx, result)
+ },
EnsureSummary: store.EnsureSummary,
FilterIgnored: func(ctx context.Context, envID, imageID string, vulns []vulnerability.Vulnerability) ([]vulnerability.Vulnerability, error) {
return s.ignores.FilterForImage(ctx, envID, imageID, vulns)
@@ -374,6 +390,7 @@ func (s *VulnerabilityService) RegisterWorkflows(engine *flow.Engine) error {
workflow.WithRetryBackoff(30*time.Second, 2*time.Minute)),
workflow.Step("finalize", engine.Handler(func(ctx context.Context, t flow.Task) (any, error) {
s.scan.ReleaseScanPool()
+ s.query.InvalidateRiskOverview()
var targets []scan.Target
if err := t.DecodeOutput("discover", &targets); err != nil {
return nil, err
diff --git a/backend/internal/vulnerability/service_test.go b/backend/internal/vulnerability/service_test.go
index 1ecfc5b25..9f58a7778 100644
--- a/backend/internal/vulnerability/service_test.go
+++ b/backend/internal/vulnerability/service_test.go
@@ -46,7 +46,7 @@ func setupVulnerabilityScanTestDB(t *testing.T) (*database.DB, *settings.Setting
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&VulnerabilityScanRecord{}, &VulnerabilityIgnore{}, &VulnerabilityScanItem{}, &settings.SettingVariable{}))
db := &database.DB{DB: gdb}
- settingsService, err := settings.NewSettingsService(t.Context(), db)
+ settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
return db, settingsService
@@ -1077,7 +1077,7 @@ func featureSettings(t *testing.T) (*settings.SettingsService, *database.DB) {
require.NoError(t, err)
require.NoError(t, gdb.AutoMigrate(&settings.SettingVariable{}, &VulnerabilityScanRecord{}, &VulnerabilityScanItem{}, &VulnerabilityReportRecord{}, &VulnerabilityIgnore{}))
db := &database.DB{DB: gdb}
- svc, err := settings.NewSettingsService(t.Context(), db)
+ svc, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
diff --git a/backend/pkg/libarcane/registryauth/helpers.go b/backend/pkg/libarcane/registryauth/helpers.go
index e052893b2..347e264ac 100644
--- a/backend/pkg/libarcane/registryauth/helpers.go
+++ b/backend/pkg/libarcane/registryauth/helpers.go
@@ -31,7 +31,7 @@ func ExtractRegistryHost(imageRef string) string {
return "docker.io"
}
- return kit.Ternary(!strings.Contains(hostCandidate, ".") && !strings.Contains(hostCandidate, ":"), "docker.io", hostCandidate)
+ return kit.Ternary(!strings.Contains(hostCandidate, ".") && !strings.Contains(hostCandidate, ":") && hostCandidate != "localhost", "docker.io", hostCandidate)
}
// SplitRegistryURL separates a registry URL into its comparison host and an
diff --git a/backend/pkg/libarcane/settings.go b/backend/pkg/libarcane/settings.go
index d123b29ad..83b5ac6c8 100644
--- a/backend/pkg/libarcane/settings.go
+++ b/backend/pkg/libarcane/settings.go
@@ -52,7 +52,6 @@ var timeoutSettingKeys = []string{
"buildsDirectory",
"buildTimeout",
"depotProjectId",
- DepotTokenSettingKey,
}
var cronSettingKeys = []string{
diff --git a/backend/pkg/scheduler/actor_test.go b/backend/pkg/scheduler/actor_test.go
index d44eb45be..117cf1faf 100644
--- a/backend/pkg/scheduler/actor_test.go
+++ b/backend/pkg/scheduler/actor_test.go
@@ -11,6 +11,7 @@ import (
"github.com/stretchr/testify/require"
"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/kv"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
@@ -91,7 +92,7 @@ func stopJobSchedulerForTestInternal(ctx context.Context, scheduler *jobSchedule
func newSettingsServiceForTestInternal(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
- svc, err := settings.NewSettingsService(ctx, db)
+ svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}