Skip to content

Modern Docker Management, Designed for Everyone

feat: allow decimal CPU limits for Trivy scans (#3972)

Kyle Mendell02225a2d0352
diff --git a/backend/internal/vulnerability/service_test.go b/backend/internal/vulnerability/service_test.go
index 03e5be454..4385fa120 100644
--- a/backend/internal/vulnerability/service_test.go
+++ b/backend/internal/vulnerability/service_test.go
@@ -6,6 +6,9 @@ import (
"context"
"encoding/json"
"fmt"
+ "net/http"
+ "net/http/httptest"
+ "sync/atomic"
"testing"
"time"
@@ -13,10 +16,12 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/kv"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/types/v2/vulnerability"
"github.com/libtnb/sqlite"
+ "github.com/moby/moby/client"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
)
@@ -58,6 +63,225 @@ func TestBuildTrivyContainerResourcesInternal_CustomLimits(t *testing.T) {
require.Equal(t, int64(2_500_000_000), resources.NanoCPUs)
require.Equal(t, int64(2_147_483_648), resources.Memory)
require.Equal(t, int64(2_147_483_648), resources.MemorySwap)
+
+ for _, tc := range []struct {
+ name string
+ cpu string
+ info string
+ infoFail bool
+ slowInfo bool
+ expired bool
+ noClient bool
+ quota int64
+ cpuSet string
+ }{
+ {name: "fractional quota", cpu: "0.5", info: `{"CPUCfsQuota":true,"CPUSet":true,"NCPU":4,"OperatingSystem":"Linux"}`, quota: 500_000_000},
+ {name: "one and a half cores", cpu: "1.5", info: `{"CPUCfsQuota":true,"CPUSet":true,"NCPU":4}`, quota: 1_500_000_000},
+ {name: "Synology overrides reported quota support", cpu: "0.5", info: `{"CPUCfsQuota":true,"CPUSet":true,"NCPU":4,"OperatingSystem":"Synology NAS"}`, cpuSet: "0"},
+ {name: "older DiskStation", cpu: "1.5", info: `{"CPUCfsQuota":true,"CPUSet":true,"NCPU":4,"OperatingSystem":"DiskStation"}`, cpuSet: "0"},
+ {name: "no quotas", cpu: "2.5", info: `{"CPUSet":true,"NCPU":4}`, cpuSet: "0-1"},
+ {name: "no CPU controls", cpu: "0.5", info: `{"NCPU":4}`},
+ {name: "CPU limit disabled", cpu: "0", infoFail: true},
+ {name: "capability lookup fails", cpu: "0.5", infoFail: true, quota: 500_000_000},
+ {name: "capability lookup times out", cpu: "0.5", slowInfo: true, quota: 500_000_000},
+ {name: "capability lookup deadline", cpu: "0.5", expired: true},
+ {name: "no Docker client", cpu: "0.5", noClient: true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ settingsSvc, _ := featureSettingsInternal(t)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), "trivyResourceLimitsEnabled", true))
+ require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "trivyCpuLimit", tc.cpu))
+ require.NoError(t, settingsSvc.SetIntSetting(t.Context(), "trivyMemoryLimitMb", 2048))
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if tc.cpu == "0" {
+ t.Error("CPU capability lookup should be skipped when the CPU limit is disabled")
+ }
+ if r.URL.Path != "/v1.41/info" {
+ t.Errorf("unexpected Docker request: %s", r.URL.Path)
+ http.NotFound(w, r)
+ return
+ }
+ if tc.infoFail {
+ http.Error(w, "capability lookup unavailable", http.StatusInternalServerError)
+ return
+ }
+ if tc.slowInfo {
+ <-r.Context().Done()
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ if _, err := fmt.Fprint(w, tc.info); err != nil {
+ t.Errorf("write Docker info: %v", err)
+ }
+ }))
+ defer server.Close()
+ httpClient := server.Client()
+ if tc.slowInfo {
+ httpClient.Timeout = 20 * time.Millisecond
+ }
+ dockerClient, err := client.New(client.WithHost(server.URL), client.WithAPIVersion("1.41"), client.WithHTTPClient(httpClient))
+ require.NoError(t, err)
+ defer dockerClient.Close()
+ svc := &VulnerabilityService{settingsService: settingsSvc}
+ ctx := t.Context()
+ if tc.expired {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithDeadline(ctx, time.Now().Add(-time.Second))
+ defer cancel()
+ }
+ if tc.noClient {
+ dockerClient = nil
+ }
+ actual, cpuSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(ctx, dockerClient)
+ if tc.expired || tc.noClient {
+ require.Error(t, err)
+ if tc.expired {
+ require.ErrorIs(t, err, context.DeadlineExceeded)
+ }
+ require.Zero(t, actual.NanoCPUs)
+ require.Empty(t, cpuSet)
+ require.False(t, apply, "failed capability lookup must not apply unverified CPU limits")
+ return
+ }
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, tc.quota, actual.NanoCPUs)
+ require.Equal(t, tc.cpuSet, cpuSet)
+ require.Equal(t, int64(2_147_483_648), actual.Memory)
+ require.Equal(t, int64(2_147_483_648), actual.MemorySwap)
+ })
+ }
+
+ for _, quotaSupported := range []bool{true, false} {
+ t.Run(fmt.Sprintf("persistent capabilities quota=%t", quotaSupported), func(t *testing.T) {
+ settingsSvc, db := featureSettingsInternal(t)
+ require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
+ store := kv.NewKVService(db)
+ require.NoError(t, settingsSvc.SetBoolSetting(t.Context(), "trivyResourceLimitsEnabled", true))
+ require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "trivyCpuLimit", "2.5"))
+ require.NoError(t, settingsSvc.SetIntSetting(t.Context(), "trivyMemoryLimitMb", 2048))
+ var status, requests atomic.Int32
+ status.Store(http.StatusOK)
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ requests.Add(1)
+ if code := int(status.Load()); code != http.StatusOK {
+ http.Error(w, "info unavailable", code)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ if _, err := fmt.Fprintf(w, `{"CPUCfsQuota":%t,"CPUSet":true,"NCPU":4}`, quotaSupported); err != nil {
+ t.Errorf("write Docker info: %v", err)
+ }
+ }))
+ defer server.Close()
+ dockerClient, err := client.New(client.WithHost(server.URL), client.WithAPIVersion("1.41"))
+ require.NoError(t, err)
+ defer dockerClient.Close()
+ svc := &VulnerabilityService{settingsService: settingsSvc, kvService: store}
+ first, firstCPUSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, int32(1), requests.Load())
+ if quotaSupported {
+ require.Equal(t, int64(2_500_000_000), first.NanoCPUs)
+ require.Empty(t, firstCPUSet)
+ } else {
+ require.Zero(t, first.NanoCPUs)
+ require.Equal(t, "0-1", firstCPUSet)
+ }
+
+ // A new service instance reuses persisted capabilities without calling Docker.
+ svc = &VulnerabilityService{settingsService: settingsSvc, kvService: kv.NewKVService(db)}
+ status.Store(http.StatusForbidden)
+ cached, cpuSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, first, cached)
+ require.Equal(t, firstCPUSet, cpuSet)
+ require.Equal(t, int32(1), requests.Load())
+
+ // Cache capabilities, not the configured limit.
+ require.NoError(t, settingsSvc.SetStringSetting(t.Context(), "trivyCpuLimit", "0.5"))
+ cached, cpuSet, _, err = svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ if quotaSupported {
+ require.Equal(t, int64(500_000_000), cached.NanoCPUs)
+ } else {
+ require.Equal(t, "0", cpuSet)
+ }
+ require.Equal(t, int32(1), requests.Load())
+
+ entries, err := store.ListByPrefix(t.Context(), "trivy:cpu-capabilities:v1:")
+ require.NoError(t, err)
+ require.Len(t, entries, 1)
+ var expired trivyCPUCapabilitiesInternal
+ require.NoError(t, json.Unmarshal([]byte(entries[0].Value), &expired))
+ expired.FetchedAt = time.Now().Add(-2 * trivyCPUCapabilitiesCacheTTL)
+ payload, err := json.Marshal(expired)
+ require.NoError(t, err)
+ require.NoError(t, store.Set(t.Context(), entries[0].Key, string(payload)))
+ stale, staleCPUSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, cached, stale)
+ require.Equal(t, cpuSet, staleCPUSet)
+ require.Equal(t, int32(2), requests.Load())
+
+ status.Store(http.StatusOK)
+ _, _, _, err = svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.Equal(t, int32(3), requests.Load())
+ raw, found, err := store.Get(t.Context(), entries[0].Key)
+ require.NoError(t, err)
+ require.True(t, found)
+ var refreshed trivyCPUCapabilitiesInternal
+ require.NoError(t, json.Unmarshal([]byte(raw), &refreshed))
+ require.True(t, refreshed.FetchedAt.After(expired.FetchedAt))
+
+ status.Store(http.StatusInternalServerError)
+ otherServer := httptest.NewServer(server.Config.Handler)
+ defer otherServer.Close()
+ for _, endpoint := range []struct{ host, version string }{
+ {server.URL, "1.42"},
+ {otherServer.URL, "1.41"},
+ } {
+ otherClient, err := client.New(client.WithHost(endpoint.host), client.WithAPIVersion(endpoint.version))
+ require.NoError(t, err)
+ defer otherClient.Close()
+ fallback, cpuSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), otherClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, int64(500_000_000), fallback.NanoCPUs)
+ require.Empty(t, cpuSet)
+ require.Equal(t, int64(2_147_483_648), fallback.Memory)
+ }
+
+ require.NoError(t, store.Set(t.Context(), entries[0].Key, "invalid JSON"))
+ fallback, cpuSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, int64(500_000_000), fallback.NanoCPUs)
+ require.Empty(t, cpuSet)
+ require.Equal(t, int64(2_147_483_648), fallback.Memory)
+ require.Equal(t, int64(2_147_483_648), fallback.MemorySwap)
+
+ // Cache storage failures must not prevent a live lookup or a safe fallback.
+ require.NoError(t, db.Migrator().DropTable(&kv.KVEntry{}))
+ status.Store(http.StatusOK)
+ live, liveCPUSet, apply, err := svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, cached, live)
+ require.Equal(t, staleCPUSet, liveCPUSet)
+ status.Store(http.StatusInternalServerError)
+ fallback, cpuSet, apply, err = svc.getTrivyContainerResourceOptionsInternal(t.Context(), dockerClient)
+ require.NoError(t, err)
+ require.True(t, apply)
+ require.Equal(t, int64(500_000_000), fallback.NanoCPUs)
+ require.Empty(t, cpuSet)
+ require.Equal(t, int64(2_147_483_648), fallback.Memory)
+ })
+ }
}
func TestBuildTrivyCommandArgs_WithCacheDir(t *testing.T) {
diff --git a/backend/internal/vulnerability/vulnerability.go b/backend/internal/vulnerability/vulnerability.go
index 10619e8e9..1d279fd19 100644
--- a/backend/internal/vulnerability/vulnerability.go
+++ b/backend/internal/vulnerability/vulnerability.go
@@ -10,6 +10,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/kv"
"github.com/getarcaneapp/arcane/backend/v2/internal/notification"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
@@ -36,6 +37,7 @@ type VulnerabilityService struct {
notificationService *notification.NotificationService
activityService *activity.ActivityService
registryService *registry.ContainerRegistryService
+ kvService *kv.KVService
// scanLocks provides per-image locking to allow concurrent scans of different
// images while preventing duplicate scans of the same image.
scanLocks utils.KeyedMutex
@@ -48,7 +50,7 @@ type VulnerabilityService struct {
}
// NewVulnerabilityService creates a new VulnerabilityService instance
-func NewVulnerabilityService(db *database.DB, dockerService *docker.DockerClientService, eventService *event.EventService, settingsService *settings.SettingsService, notificationService *notification.NotificationService, activityService *activity.ActivityService, registryService *registry.ContainerRegistryService) *VulnerabilityService {
+func NewVulnerabilityService(db *database.DB, dockerService *docker.DockerClientService, eventService *event.EventService, settingsService *settings.SettingsService, notificationService *notification.NotificationService, activityService *activity.ActivityService, registryService *registry.ContainerRegistryService, kvService *kv.KVService) *VulnerabilityService {
return &VulnerabilityService{
db: db,
dockerService: dockerService,
@@ -57,6 +59,7 @@ func NewVulnerabilityService(db *database.DB, dockerService *docker.DockerClient
notificationService: notificationService,
activityService: activityService,
registryService: registryService,
+ kvService: kvService,
trivyScanSlots: nil,
}
}
diff --git a/backend/internal/vulnerability/vulnerability_capabilities.go b/backend/internal/vulnerability/vulnerability_capabilities.go
new file mode 100644
index 000000000..a9af39377
--- /dev/null
+++ b/backend/internal/vulnerability/vulnerability_capabilities.go
@@ -0,0 +1,74 @@
+package vulnerability
+
+import (
+ "context"
+ "crypto/sha256"
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "time"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
+ "github.com/moby/moby/client"
+)
+
+const (
+ trivyCPUCapabilitiesCacheTTL = time.Hour
+ trivyCPUCapabilitiesLookupTimeout = 5 * time.Second
+)
+
+type trivyCPUCapabilitiesInternal struct {
+ Quota bool `json:"quota"`
+ CPUSet bool `json:"cpuSet"`
+ CPUs int `json:"cpus"`
+ FetchedAt time.Time `json:"fetchedAt"`
+}
+
+func (s *VulnerabilityService) getTrivyCPUCapabilitiesInternal(ctx context.Context, dockerClient *client.Client) (trivyCPUCapabilitiesInternal, error) {
+ key := fmt.Sprintf("trivy:cpu-capabilities:v1:%x", sha256.Sum256([]byte(dockerClient.DaemonHost()+"\x00"+dockerClient.ClientVersion())))
+ var cached trivyCPUCapabilitiesInternal
+ if s.kvService != nil {
+ raw, found, err := s.kvService.Get(ctx, key)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to read cached Trivy CPU capabilities", "error", err)
+ } else if found {
+ if err := json.Unmarshal([]byte(raw), &cached); err != nil || cached.FetchedAt.IsZero() {
+ slog.WarnContext(ctx, "ignoring invalid cached Trivy CPU capabilities", "error", err)
+ cached = trivyCPUCapabilitiesInternal{}
+ } else if age := time.Since(cached.FetchedAt); age >= 0 && age < trivyCPUCapabilitiesCacheTTL {
+ return cached, nil
+ }
+ }
+ }
+
+ infoCtx, cancel := context.WithTimeout(ctx, trivyCPUCapabilitiesLookupTimeout)
+ defer cancel()
+ info, err := dockerClient.Info(infoCtx, client.InfoOptions{})
+ if err != nil {
+ if ctx.Err() != nil {
+ return trivyCPUCapabilitiesInternal{}, ctx.Err()
+ }
+ if !cached.FetchedAt.IsZero() {
+ slog.WarnContext(ctx, "failed to refresh Trivy CPU capabilities; using cached capabilities", "error", err)
+ return cached, nil
+ }
+ return trivyCPUCapabilitiesInternal{}, err
+ }
+
+ capabilities := trivyCPUCapabilitiesInternal{
+ Quota: info.Info.CPUCfsQuota && !vuln.IsSynologyDockerHost(info.Info.OperatingSystem),
+ CPUSet: info.Info.CPUSet,
+ CPUs: info.Info.NCPU,
+ FetchedAt: time.Now().UTC(),
+ }
+ if s.kvService != nil {
+ payload, err := json.Marshal(capabilities)
+ if err == nil {
+ err = s.kvService.Set(ctx, key, string(payload))
+ }
+ if err != nil {
+ slog.WarnContext(ctx, "failed to cache Trivy CPU capabilities", "error", err)
+ }
+ }
+ return capabilities, nil
+}
diff --git a/backend/internal/vulnerability/vulnerability_trivy.go b/backend/internal/vulnerability/vulnerability_trivy.go
index aa4a55bed..80769611e 100644
--- a/backend/internal/vulnerability/vulnerability_trivy.go
+++ b/backend/internal/vulnerability/vulnerability_trivy.go
@@ -269,7 +269,10 @@ func (s *VulnerabilityService) createBatchTrivyContainer(ctx context.Context, sc
securityOpts, privileged := runtimeSecurity.securityOpts, runtimeSecurity.privileged
hostConfig := vuln.BuildBatchHostConfig(cacheVolume, runtimeOptions, securityOpts, privileged)
- resources, cpuSet, applyLimits := s.getTrivyContainerResourceOptionsInternal(ctx, dockerClient)
+ resources, cpuSet, applyLimits, err := s.getTrivyContainerResourceOptionsInternal(ctx, dockerClient)
+ if err != nil {
+ return "", err
+ }
vuln.ApplyContainerResources(hostConfig, resources, cpuSet, applyLimits)
containerID, err := s.createAndStartTrivyContainerInternal(ctx, dockerClient, "batch", config, hostConfig, files)
@@ -873,64 +876,49 @@ func (s *VulnerabilityService) getTrivyContainerResourcesInternal() mo.Option[co
return buildTrivyContainerResourcesInternal(cfg)
}
-func (s *VulnerabilityService) getTrivyContainerResourceOptionsInternal(ctx context.Context, dockerClient *client.Client) (containertypes.Resources, string, bool) {
+func (s *VulnerabilityService) getTrivyContainerResourceOptionsInternal(ctx context.Context, dockerClient *client.Client) (containertypes.Resources, string, bool, error) {
resources, applyLimits := s.getTrivyContainerResourcesInternal().Get()
- if !applyLimits || dockerClient == nil {
- return resources, "", applyLimits
+ if !applyLimits || resources.NanoCPUs == 0 {
+ return resources, "", applyLimits, nil
+ }
+ if dockerClient == nil {
+ return containertypes.Resources{}, "", false, errors.New("Docker client is required to determine Trivy CPU limits")
+ }
+ if err := ctx.Err(); err != nil {
+ return containertypes.Resources{}, "", false, err
}
- infoCtx, infoCancel := context.WithTimeout(ctx, timeouts.GetDuration(0, timeouts.DefaultDockerAPI))
- defer infoCancel()
-
- slog.DebugContext(ctx, "inspecting docker host for trivy resource strategy")
-
- info, err := dockerClient.Info(infoCtx, client.InfoOptions{})
+ capabilities, err := s.getTrivyCPUCapabilitiesInternal(ctx, dockerClient)
if err != nil {
- if errors.Is(infoCtx.Err(), context.DeadlineExceeded) || errors.Is(err, context.DeadlineExceeded) {
- slog.WarnContext(ctx,
- "timed out inspecting docker info for trivy resource strategy; falling back to default limits",
- "timeout", timeouts.DefaultDockerAPI.String(),
- "error", err,
- )
- } else {
- slog.DebugContext(ctx, "failed to inspect docker info for trivy resource strategy", "error", err)
+ if ctx.Err() != nil {
+ return containertypes.Resources{}, "", false, ctx.Err()
}
- return resources, "", applyLimits
+ slog.WarnContext(ctx, "unable to determine Trivy CPU capabilities; using configured CPU limits", "error", err)
+ return resources, "", applyLimits, nil
}
- slog.DebugContext(ctx,
- "resolved docker host info for trivy resource strategy",
- "operatingSystem", info.Info.OperatingSystem,
- "ncpu", info.Info.NCPU,
- )
-
- if info.Info.CPUCfsQuota && !vuln.IsSynologyDockerHost(info.Info.OperatingSystem) {
- return resources, "", applyLimits
+ if capabilities.Quota {
+ return resources, "", applyLimits, nil
}
cpuSet := ""
- if info.Info.CPUSet {
- cpuSet = vuln.BuildCPUSet(resources.NanoCPUs, info.Info.NCPU)
+ if capabilities.CPUSet {
+ cpuSet = vuln.BuildCPUSet(resources.NanoCPUs, capabilities.CPUs)
}
resources.NanoCPUs = 0
if cpuSet != "" {
slog.InfoContext(ctx,
"docker host does not support CPU CFS quota; applying Trivy CPU limit via cpuset",
- "operatingSystem", info.Info.OperatingSystem,
- "cpuCfsQuota", info.Info.CPUCfsQuota,
"cpuset", cpuSet,
)
} else {
slog.InfoContext(ctx,
"docker host does not support CPU CFS quota or cpuset; skipping Trivy CPU limit",
- "operatingSystem", info.Info.OperatingSystem,
- "cpuCfsQuota", info.Info.CPUCfsQuota,
- "cpuSet", info.Info.CPUSet,
)
}
- return resources, cpuSet, applyLimits
+ return resources, cpuSet, applyLimits, nil
}
func buildTrivyContainerResourcesInternal(cfg *settings.Settings) mo.Option[containertypes.Resources] {
@@ -1143,7 +1131,10 @@ func (s *VulnerabilityService) runTrivyScanInternal(ctx context.Context, scanner
}
config := vuln.BuildContainerConfig(scannerImage, cmdArgs, env)
- resources, cpuSet, applyLimits := s.getTrivyContainerResourceOptionsInternal(ctx, dockerClient)
+ resources, cpuSet, applyLimits, err := s.getTrivyContainerResourceOptionsInternal(ctx, dockerClient)
+ if err != nil {
+ return nil, err
+ }
runtimeSecurity := s.getTrivyRuntimeSecurityInternal().OrEmpty()
securityOpts, privileged := runtimeSecurity.securityOpts, runtimeSecurity.privileged
hostConfig := vuln.BuildHostConfig(
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 897243c23..7c540324b 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -1579,7 +1579,7 @@
"security_trivy_resource_limits_label": "Trivy Resource Limits",
"security_trivy_resource_limits_description": "Configure CPU and memory limits for Trivy scan containers.",
"security_trivy_cpu_limit_label": "CPU Limit (cores)",
- "security_trivy_cpu_limit_help": "Whole numbers only (for example: 1 or 2).",
+ "security_trivy_cpu_limit_help": "CPU cores, such as 0.5 or 1.5. Set 0 for no CPU limit. Hosts using CPU affinity instead of CPU quotas use whole cores.",
"security_trivy_memory_limit_label": "Memory Limit (MB)",
"security_trivy_concurrent_scan_containers_label": "Concurrent Scan Containers",
"security_trivy_concurrent_scan_containers_help": "Maximum number of Trivy scan containers that can run at the same time across manual and scheduled scans.",
diff --git a/frontend/src/lib/components/form/text-input-with-label.svelte b/frontend/src/lib/components/form/text-input-with-label.svelte
index 03603aa8b..2ab381c7f 100644
--- a/frontend/src/lib/components/form/text-input-with-label.svelte
+++ b/frontend/src/lib/components/form/text-input-with-label.svelte
@@ -1,4 +1,5 @@
<script lang="ts">
+ import type { HTMLInputAttributes } from 'svelte/elements';
import { Label } from '#lib/components/ui/label/index.js';
import { Input } from '#lib/components/ui/input/index.js';
@@ -14,6 +15,8 @@
error,
disabled = false,
type = 'text',
+ min,
+ step,
autocomplete = 'off',
required = false,
onChange
@@ -29,6 +32,8 @@
error?: string | null;
disabled?: boolean;
type?: 'text' | 'email' | 'password' | 'number' | 'url';
+ min?: HTMLInputAttributes['min'];
+ step?: HTMLInputAttributes['step'];
autocomplete?: HTMLInputElement['autocomplete'];
required?: boolean;
onChange?: (value: string) => void;
@@ -64,6 +69,8 @@
{placeholder}
{disabled}
{type}
+ {min}
+ {step}
{autocomplete}
{required}
oninput={handleInput}
diff --git a/frontend/src/lib/components/settings/trivy-security-settings.svelte b/frontend/src/lib/components/settings/trivy-security-settings.svelte
index b489c63dd..7717f3156 100644
--- a/frontend/src/lib/components/settings/trivy-security-settings.svelte
+++ b/frontend/src/lib/components/settings/trivy-security-settings.svelte
@@ -322,12 +322,15 @@
<div class="space-y-4 border-l-2 border-border/60 pl-5">
<div class="grid gap-4 sm:grid-cols-2">
<TextInputWithLabel
+ id="trivyCpuLimit"
bind:value={formInputs.trivyCpuLimit.value}
error={formInputs.trivyCpuLimit.error}
disabled={!formInputs.trivyResourceLimitsEnabled.value}
label={m.security_trivy_cpu_limit_label()}
helpText={m.security_trivy_cpu_limit_help()}
type="number"
+ min={0}
+ step="any"
/>
<TextInputWithLabel
bind:value={formInputs.trivyMemoryLimitMb.value}
diff --git a/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts b/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
index 15ea711e5..4e42e5009 100644
--- a/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
+++ b/frontend/src/routes/(app)/environments/[id]/components/environment-form-schema.ts
@@ -41,7 +41,7 @@ export const environmentFormSchema = z
trivySecurityOpts: z.string(),
trivyPrivileged: z.boolean(),
trivyResourceLimitsEnabled: z.boolean(),
- trivyCpuLimit: z.coerce.number().int(m.security_session_timeout_integer()).nonnegative(),
+ trivyCpuLimit: z.coerce.number().nonnegative(),
trivyMemoryLimitMb: z.coerce.number().int().nonnegative(),
trivyConcurrentScanContainers: z.coerce.number().int().min(1, m.security_trivy_concurrent_scan_containers_min()),
trivyServerEnabled: z.boolean(),
diff --git a/tests/spec/environment-settings.spec.ts b/tests/spec/environment-settings.spec.ts
index eb86d89df..8f62a3713 100644
--- a/tests/spec/environment-settings.spec.ts
+++ b/tests/spec/environment-settings.spec.ts
@@ -1,4 +1,4 @@
-import { test, expect, type Locator, type Page } from '../fixtures/test.fixture';
+import { test, expect, type Locator, type Page, type Request } from '../fixtures/test.fixture';
const LOCAL_ENV_ID = '0';
const NAME_PLACEHOLDER = 'My Lab Server';
@@ -310,6 +310,76 @@ test.describe('Environment Settings UI', () => {
}
});
+ test('should save decimal trivy CPU limits and reject negative values', async ({ page }) => {
+ test.setTimeout(120_000);
+ const settingsPath = `/api/environments/${LOCAL_ENV_ID}/settings`;
+ const settingsResponse = await page.request.get(settingsPath);
+ expect(settingsResponse.ok()).toBeTruthy();
+ const settings = (await settingsResponse.json()) as Array<{ key: string; value: string }>;
+ const originalSettings = Object.fromEntries(
+ settings
+ .filter(({ key }) =>
+ ['trivyResourceLimitsEnabled', 'trivyCpuLimit', 'trivyMemoryLimitMb'].includes(key)
+ )
+ .map(({ key, value }) => [key, value])
+ );
+ expect(Object.keys(originalSettings)).toHaveLength(3);
+
+ try {
+ await openLocalEnvironment(page);
+ await page.getByRole('tab', { name: 'Security', exact: true }).click();
+ await page.locator('#trivyResourceLimitsEnabledSwitch').setChecked(true);
+ const cpuInput = page.getByRole('spinbutton', { name: 'CPU Limit (cores)', exact: true });
+ await expect(cpuInput).toHaveAttribute('min', '0');
+ await expect(cpuInput).toHaveAttribute('step', 'any');
+
+ const values = ['0.5', '1.5', '2.5', '0.25', '1', '0'];
+ if ((await cpuInput.inputValue()) === values[0]) values.reverse();
+
+ for (const value of values) {
+ await cpuInput.fill(value);
+ expect(await cpuInput.evaluate((input: HTMLInputElement) => input.validity.valid)).toBe(
+ true
+ );
+ const requestPromise = page.waitForRequest(
+ (request) =>
+ request.method() === 'PUT' && new URL(request.url()).pathname === settingsPath
+ );
+ await saveAndWaitForPut(page, settingsPath);
+ const payload = (await requestPromise).postDataJSON() as Record<string, unknown>;
+ expect(payload.trivyCpuLimit).toBe(value);
+ expect(payload.trivyResourceLimitsEnabled).toBe('true');
+ await page.reload();
+ await page.getByRole('tab', { name: 'Security', exact: true }).click();
+ await expect(cpuInput).toHaveValue(value);
+ }
+
+ const writes: Request[] = [];
+ const recordWrite = (request: Request) => {
+ if (request.method() === 'PUT' && new URL(request.url()).pathname === settingsPath) {
+ writes.push(request);
+ }
+ };
+ page.on('request', recordWrite);
+ try {
+ await cpuInput.fill('-0.5');
+ await page.getByRole('button', { name: 'Save', exact: true }).first().click();
+ await expect(
+ page.getByText('Please check the form for errors.', { exact: true })
+ ).toBeVisible();
+ expect(writes).toHaveLength(0);
+ await page.reload();
+ await page.getByRole('tab', { name: 'Security', exact: true }).click();
+ await expect(cpuInput).toHaveValue(values[values.length - 1]);
+ } finally {
+ page.off('request', recordWrite);
+ }
+ } finally {
+ const restored = await page.request.put(settingsPath, { data: originalSettings });
+ expect(restored.ok()).toBeTruthy();
+ }
+ });
+
test('should update and save the trivy network mode including auto', async ({ page }) => {
await openLocalEnvironment(page);
await page.getByRole('tab', { name: 'Security', exact: true }).click();