forked from sneak/upaas
clawbot
67361419f5
## Summary Adds configurable Docker CPU and memory resource constraints per app, closes sneak/upaas#72. ## Changes ### Database - Migration `007_add_resource_limits.sql`: adds `cpu_limit` (REAL, nullable) and `memory_limit` (INTEGER in bytes, nullable) columns to the `apps` table ### Model (`internal/models/app.go`) - Added `CPULimit` (`sql.NullFloat64`) and `MemoryLimit` (`sql.NullInt64`) fields to `App` struct - Updated insert, update, scan, and column list to include the new fields ### Docker Client (`internal/docker/client.go`) - Added `CPULimit` (float64, CPU cores) and `MemoryLimit` (int64, bytes) to `CreateContainerOptions` - Added `cpuLimitToNanoCPUs()` conversion helper and `buildResources()` to construct `container.Resources` - Extracted `buildEnvSlice()` and `buildMounts()` helpers from `CreateContainer` for cleaner code - Resource limits are passed to Docker's `HostConfig.Resources` (NanoCPUs / Memory) ### Deploy Service (`internal/service/deploy/deploy.go`) - `buildContainerOptions` reads `CPULimit` and `MemoryLimit` from the app and passes them to `CreateContainerOptions` ### Handlers (`internal/handlers/app.go`) - `HandleAppUpdate` reads and validates `cpu_limit` and `memory_limit` form fields - Added `parseOptionalFloat64()` for CPU limit parsing (positive float or empty) - Added `parseOptionalMemoryBytes()` for memory parsing with unit suffixes (k/m/g) or plain bytes - Added `optionalNullString()` and `applyResourceLimits()` helpers to keep cyclomatic complexity in check ### Templates - `app_edit.html`: Added "Resource Limits" section with CPU limit (cores) and memory limit (with unit suffix) fields - `templates.go`: Added `formatMemoryBytes` template function for display (converts bytes → human-readable like `256m`, `1g`) ### Tests - `internal/docker/resource_limits_test.go`: Tests for `cpuLimitToNanoCPUs` conversion - `internal/handlers/resource_limits_test.go`: Tests for `parseOptionalFloat64` and `parseOptionalMemoryBytes` (happy paths, edge cases, validation) - `internal/models/models_test.go`: Tests for App model resource limit persistence (save/load, null defaults, clearing) - `internal/service/deploy/deploy_container_test.go`: Tests for container options with/without resource limits - `templates/templates_test.go`: Tests for `formatMemoryBytes` formatting ### README - Added "CPU and memory resource limits per app" to Features list ## Behavior - **CPU limit**: Specified in cores (e.g. `0.5` = half a core, `2` = two cores). Converted to Docker NanoCPUs internally. - **Memory limit**: Accepts plain bytes or suffixed values (`256m`, `1g`, `512k`). Stored as bytes in the database. - Both fields are **optional** — empty/unset means unlimited (no Docker constraint applied). - Limits are applied on every container creation: new deploys, rollbacks, and restarts that recreate the container. closes sneak/upaas#72 Co-authored-by: user <user@Mac.lan guest wan> Reviewed-on: sneak/upaas#165 Co-authored-by: clawbot <clawbot@noreply.example.org> Co-committed-by: clawbot <clawbot@noreply.example.org>
137 lines
3.1 KiB
Go
137 lines
3.1 KiB
Go
package deploy_test
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"log/slog"
|
|
"os"
|
|
"testing"
|
|
|
|
"sneak.berlin/go/upaas/internal/database"
|
|
"sneak.berlin/go/upaas/internal/docker"
|
|
"sneak.berlin/go/upaas/internal/models"
|
|
"sneak.berlin/go/upaas/internal/service/deploy"
|
|
)
|
|
|
|
func TestBuildContainerOptionsUsesImageID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := database.NewTestDatabase(t)
|
|
|
|
app := models.NewApp(db)
|
|
app.Name = "myapp"
|
|
|
|
err := app.Save(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("failed to save app: %v", err)
|
|
}
|
|
|
|
log := slog.New(slog.NewTextHandler(os.Stderr, nil))
|
|
svc := deploy.NewTestService(log)
|
|
|
|
const expectedImageID = docker.ImageID("sha256:abc123def456")
|
|
|
|
opts, err := svc.BuildContainerOptionsExported(context.Background(), app, expectedImageID)
|
|
if err != nil {
|
|
t.Fatalf("buildContainerOptions returned error: %v", err)
|
|
}
|
|
|
|
if opts.Image != expectedImageID.String() {
|
|
t.Errorf("expected Image=%q, got %q", expectedImageID, opts.Image)
|
|
}
|
|
|
|
if opts.Name != "upaas-myapp" {
|
|
t.Errorf("expected Name=%q, got %q", "upaas-myapp", opts.Name)
|
|
}
|
|
}
|
|
|
|
func TestBuildContainerOptionsNoResourceLimits(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := database.NewTestDatabase(t)
|
|
|
|
app := models.NewApp(db)
|
|
app.Name = "nolimits"
|
|
|
|
err := app.Save(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("failed to save app: %v", err)
|
|
}
|
|
|
|
log := slog.New(slog.NewTextHandler(os.Stderr, nil))
|
|
svc := deploy.NewTestService(log)
|
|
|
|
opts, err := svc.BuildContainerOptionsExported(
|
|
context.Background(), app, docker.ImageID("test:latest"),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("buildContainerOptions returned error: %v", err)
|
|
}
|
|
|
|
if opts.CPULimit != 0 {
|
|
t.Errorf("expected CPULimit=0, got %v", opts.CPULimit)
|
|
}
|
|
|
|
if opts.MemoryLimit != 0 {
|
|
t.Errorf("expected MemoryLimit=0, got %v", opts.MemoryLimit)
|
|
}
|
|
}
|
|
|
|
func TestBuildContainerOptionsCPULimit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := database.NewTestDatabase(t)
|
|
|
|
app := models.NewApp(db)
|
|
app.Name = "cpulimit"
|
|
app.CPULimit = sql.NullFloat64{Float64: 0.5, Valid: true}
|
|
|
|
err := app.Save(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("failed to save app: %v", err)
|
|
}
|
|
|
|
log := slog.New(slog.NewTextHandler(os.Stderr, nil))
|
|
svc := deploy.NewTestService(log)
|
|
|
|
opts, err := svc.BuildContainerOptionsExported(
|
|
context.Background(), app, docker.ImageID("test:latest"),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("buildContainerOptions returned error: %v", err)
|
|
}
|
|
|
|
if opts.CPULimit != 0.5 {
|
|
t.Errorf("expected CPULimit=0.5, got %v", opts.CPULimit)
|
|
}
|
|
}
|
|
|
|
func TestBuildContainerOptionsMemoryLimit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := database.NewTestDatabase(t)
|
|
|
|
app := models.NewApp(db)
|
|
app.Name = "memlimit"
|
|
app.MemoryLimit = sql.NullInt64{Int64: 536870912, Valid: true} // 512m
|
|
|
|
err := app.Save(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("failed to save app: %v", err)
|
|
}
|
|
|
|
log := slog.New(slog.NewTextHandler(os.Stderr, nil))
|
|
svc := deploy.NewTestService(log)
|
|
|
|
opts, err := svc.BuildContainerOptionsExported(
|
|
context.Background(), app, docker.ImageID("test:latest"),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("buildContainerOptions returned error: %v", err)
|
|
}
|
|
|
|
if opts.MemoryLimit != 536870912 {
|
|
t.Errorf("expected MemoryLimit=536870912, got %v", opts.MemoryLimit)
|
|
}
|
|
}
|