Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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.goindex 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.NotificationServiceactivityService *activity.ActivityServiceregistryService *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.DockerClientnotificationService: notificationService,activityService: activityService,registryService: registryService,+ kvService: kvService,trivyScanSlots: nil,}}diff --git a/backend/internal/vulnerability/vulnerability_capabilities.go b/backend/internal/vulnerability/vulnerability_capabilities.gonew file mode 100644index 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.goindex 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, scsecurityOpts, privileged := runtimeSecurity.securityOpts, runtimeSecurity.privilegedhostConfig := 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[coreturn 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 = 0if 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.privilegedhostConfig := vuln.BuildHostConfig(diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex 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.svelteindex 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.svelteindex 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"/><TextInputWithLabelbind: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.tsindex 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 = ztrivySecurityOpts: 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.tsindex 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();