Skip to content

Modern Docker Management, Designed for Everyone

refactor: inline logic in project services

Kyle Mendell73b43dba1e83
diff --git a/backend/internal/project/children/deployment/service.go b/backend/internal/project/children/deployment/service.go
index e372288a1..80eaea6c7 100644
--- a/backend/internal/project/children/deployment/service.go
+++ b/backend/internal/project/children/deployment/service.go
@@ -19,7 +19,6 @@ import (
usertypes "github.com/getarcaneapp/arcane/types/v2/user"
"go.getarcane.app/acfs"
buildtypes "go.getarcane.app/builds/types"
- "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
"github.com/getarcaneapp/arcane/backend/v2/internal/image"
@@ -48,28 +47,6 @@ func New(settingsService *settings.SettingsService, imageService *image.ImageSer
return &Service{settingsService: settingsService, imageService: imageService, dockerService: dockerService, buildService: buildService}
}
-// PullImages pulls every pullable image of the Compose project.
-func (s *Service) PullImages(ctx context.Context, compProj *composetypes.Project, progressWriter io.Writer, user usertypes.Actor, credentials []containerregistry.Credential) error {
- for _, img := range projects.PullableImageRefs(compProj) {
- if err := s.Pull(ctx, img, progressWriter, user, credentials); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (s *Service) reconcilePulledInternal(ctx context.Context, imageRefs []string) {
- if s.imageService == nil {
- return
- }
-
- for _, imageRef := range imageRefs {
- if err := s.imageService.ReconcilePulledImageUpdate(ctx, imageRef); err != nil {
- slog.WarnContext(ctx, "failed to reconcile pulled image update state", "image", imageRef, "error", err)
- }
- }
-}
-
// Pull pulls one image within the configured pull timeout and reconciles its
// update state.
func (s *Service) Pull(
@@ -95,7 +72,9 @@ func (s *Service) Pull(
return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
}
- s.reconcilePulledInternal(ctx, []string{imageRef})
+ if err := s.imageService.ReconcilePulledImageUpdate(ctx, imageRef); err != nil {
+ slog.WarnContext(ctx, "failed to reconcile pulled image update state", "image", imageRef, "error", err)
+ }
return nil
}
@@ -160,48 +139,12 @@ func (s *Service) ImageOperations(user *usertypes.Actor, credentials []container
return operations
}
-// ensureProjectBindDirectoryInternal creates source (and missing parents)
-// when it resolves inside projectPath and nothing exists there yet. Sources
-// escaping the project, lexically or through a symlink, are skipped.
-func EnsureProjectBindDirectory(ctx context.Context, projectPath, source string) error {
- logicalPath, err := acfs.LogicalPath(projectPath, source)
- if err != nil {
- return kit.Ternary(errors.Is(err, acfs.ErrOutsideRoot), nil, err)
- }
- if logicalPath == "/" {
- return nil
- }
-
- exists, err := acfs.Exists(ctx, projectPath, logicalPath)
- if errors.Is(err, acfs.ErrOutsideRoot) || exists {
- return nil
- }
- if errors.Is(err, fs.ErrPermission) {
- // Leave sources Arcane cannot inspect to the Docker daemon.
- return nil
- }
- if err != nil {
- return err
- }
-
- if mkdirAllErr := acfs.MkdirAll(ctx, projectPath, logicalPath, utils.DirPerm); mkdirAllErr != nil {
- return kit.Ternary(errors.Is(mkdirAllErr, acfs.ErrOutsideRoot), nil, mkdirAllErr)
- }
- slog.InfoContext(ctx, "created missing bind directory for project deployment", "projectPath", projectPath, "source", source)
- return nil
-}
-
-// prepareProjectBindDirectoriesInternal returns the load-time preparation for
-// deployments: bind-mount sources confirmed missing inside projectPath are
-// created as Arcane's runtime user before containers are stopped or created.
-// Left to Docker, those directories would be created as root (#4132).
+// PrepareProjectBindDirectories creates missing bind-mount sources inside
+// projectPath as Arcane's runtime user before deploys; Docker would create them as root (#4132).
//
-// Only bind sources with Compose's automatic host path creation enabled are
-// considered (short syntax, or long syntax without create_host_path: false),
-// mirroring what the daemon would otherwise do. Existing files, directories,
-// and symlinks are left untouched, as are sources outside the project
-// directory or reached through a symlink escaping it (#4195). Those sources
-// and sources Arcane cannot inspect are left to Docker, even if missing.
+// Only sources with Compose's automatic host path creation are considered.
+// Existing paths, sources escaping the project lexically or through a symlink
+// (#4195), and sources Arcane cannot inspect are left to Docker.
func PrepareProjectBindDirectories(projectPath string) projects.PrepareProjectFunc {
return func(ctx context.Context, project *composetypes.Project) error {
for _, serviceName := range slices.Sorted(maps.Keys(project.Services)) {
@@ -212,7 +155,21 @@ func PrepareProjectBindDirectories(projectPath string) projects.PrepareProjectFu
if volume.Bind != nil && !bool(volume.Bind.CreateHostPath) {
continue
}
- if err := EnsureProjectBindDirectory(ctx, projectPath, volume.Source); err != nil {
+ logicalPath, err := acfs.LogicalPath(projectPath, volume.Source)
+ if err == nil && logicalPath != "/" {
+ exists, existsErr := acfs.Exists(ctx, projectPath, logicalPath)
+ switch {
+ case exists || errors.Is(existsErr, acfs.ErrOutsideRoot) || errors.Is(existsErr, fs.ErrPermission):
+ // Leave existing, escaping, and uninspectable sources to the Docker daemon.
+ case existsErr != nil:
+ err = existsErr
+ default:
+ if err = acfs.MkdirAll(ctx, projectPath, logicalPath, utils.DirPerm); err == nil {
+ slog.InfoContext(ctx, "created missing bind directory for project deployment", "projectPath", projectPath, "source", volume.Source)
+ }
+ }
+ }
+ if err != nil && !errors.Is(err, acfs.ErrOutsideRoot) {
return fmt.Errorf("bind source %s for service %s: %w", volume.Source, serviceName, err)
}
}
diff --git a/backend/internal/project/children/details/service.go b/backend/internal/project/children/details/service.go
index 1bc467865..a599989b7 100644
--- a/backend/internal/project/children/details/service.go
+++ b/backend/internal/project/children/details/service.go
@@ -64,27 +64,6 @@ func (s *Service) ComposeContainers(ctx context.Context) ([]container.Summary, e
return projects.ListGlobalComposeContainers(ctx, dockerClient, s.dockerService.DockerHost())
}
-// runtimeImageIDsByContainerInternal maps a Compose project's container IDs to
-// their runtime image IDs. Compose ps omits image IDs, so one batched container
-// list supplies them; a listing failure only leaves image-level checks unmatched.
-func (s *Service) runtimeImageIDsByContainerInternal(ctx context.Context, projectName string) map[string]string {
- imageIDs := make(map[string]string)
- if s.dockerService == nil {
- return imageIDs
- }
- containers, err := s.ComposeContainers(ctx)
- if err != nil {
- slog.WarnContext(ctx, "failed to list containers for project image identity", "projectName", projectName, "error", err)
- return imageIDs
- }
- for _, c := range containers {
- if docker.ComposeProjectLabel(c.Labels) == projectName && c.ImageID != "" {
- imageIDs[c.ID] = c.ImageID
- }
- }
- return imageIDs
-}
-
// ComposeServices reports every Compose service with its container state,
// including services that have no container yet.
func (s *Service) ComposeServices(
@@ -104,7 +83,20 @@ func (s *Service) ComposeServices(
slog.ErrorContext(ctx, "compose ps error", "projectName", composeProject.Name, "error", err)
return nil, fmt.Errorf("failed to get compose services status: %w", err)
}
- imageIDs := s.runtimeImageIDsByContainerInternal(ctx, composeProject.Name)
+ // Compose ps omits image IDs, so one container list supplies them; a listing
+ // failure only leaves image-level checks unmatched.
+ imageIDs := make(map[string]string)
+ if s.dockerService != nil {
+ if summaries, listErr := s.ComposeContainers(ctx); listErr != nil {
+ slog.WarnContext(ctx, "failed to list containers for project image identity", "projectName", composeProject.Name, "error", listErr)
+ } else {
+ for _, c := range summaries {
+ if docker.ComposeProjectLabel(c.Labels) == composeProject.Name && c.ImageID != "" {
+ imageIDs[c.ID] = c.ImageID
+ }
+ }
+ }
+ }
currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
have := map[string]bool{}
@@ -328,8 +320,8 @@ func MergeProjectContainerUpdateInfo(base map[string]*imagetypes.UpdateInfo, ser
return result
}
-// configuredRuntimeServiceUpdateInfoInternal also binds runtime checks to the
-// current Compose source, since container labels may predate an operator edit.
+// ConfiguredRuntimeServiceUpdateInfo binds runtime checks to the current Compose
+// source, since container labels may predate an operator edit.
func ConfiguredRuntimeServiceUpdateInfo(services []types.ServiceConfig, runtime []project.RuntimeService, scoped map[string]*imagetypes.UpdateInfo) map[string]*imagetypes.UpdateInfo {
configs := make(map[string]types.ServiceConfig, len(services))
for _, service := range services {
@@ -358,14 +350,6 @@ func ConfiguredRuntimeServiceUpdateInfo(services []types.ServiceConfig, runtime
return result
}
-func GroupUpdateRecordsByProject(records []imageupdate.ImageUpdateRecord) map[string][]imageupdate.ImageUpdateRecord {
- grouped := make(map[string][]imageupdate.ImageUpdateRecord)
- for _, record := range records {
- grouped[record.ProjectID] = append(grouped[record.ProjectID], record)
- }
- return grouped
-}
-
func ExcludeHiddenRuntimeServices(details []project.Details) (map[string]map[string]bool, map[string]map[string]bool) {
hiddenServicesByProjectID := make(map[string]map[string]bool)
hiddenRefsByProjectID := make(map[string]map[string]bool)
@@ -393,35 +377,20 @@ func ExcludeHiddenRuntimeServices(details []project.Details) (map[string]map[str
return hiddenServicesByProjectID, hiddenRefsByProjectID
}
-// suppressOverrideForComposeSelectionInternal reports whether an Arcane-managed
-// override should be hidden from the details response: a COMPOSE_FILE selection
-// is active and does not list the detected override file (docker skips
-// auto-overrides for an explicit file set). Paths are compared in full, not by
-// base name, so a same-named file in a subdirectory does not count as the
-// project-root override.
-func SuppressOverrideForComposeSelection(selection []string, overridePath string) bool {
- if len(selection) == 0 {
- return false
- }
- if overridePath == "" {
- return true
- }
- absOverride, err := filepath.Abs(filepath.Clean(overridePath))
- if err != nil {
- return true
- }
- // Selection entries are already absolute, cleaned paths.
- return !slices.Contains(selection, absOverride)
-}
-
-// resolveDetailsOverrideInternal resolves the override file name and content for
-// the details response. When a COMPOSE_FILE selection is active and does not
-// include the override, it is suppressed so the UI does not invite edits that
-// deploy would ignore.
+// ResolveDetailsOverride returns the override file name and content, hidden when
+// a COMPOSE_FILE selection omits it since deploy would ignore edits to it.
func ResolveDetailsOverride(projectPath, overrideContent string, composeSelection []string) (fileName, content string) {
overridePath := projects.DetectComposeOverrideFile(projectPath)
- if SuppressOverrideForComposeSelection(composeSelection, overridePath) {
- return "", ""
+ if len(composeSelection) > 0 {
+ if overridePath == "" {
+ return "", ""
+ }
+ // Selection entries are absolute and cleaned; compare full paths so a
+ // same-named file in a subdirectory is not the project-root override.
+ absOverride, err := filepath.Abs(filepath.Clean(overridePath))
+ if err != nil || !slices.Contains(composeSelection, absOverride) {
+ return "", ""
+ }
}
if overridePath != "" {
fileName = filepath.Base(overridePath)
@@ -429,10 +398,8 @@ func ResolveDetailsOverride(projectPath, overrideContent string, composeSelectio
return fileName, overrideContent
}
-// composeSelectionRelativePathsInternal converts a multi-file COMPOSE_FILE
-// selection (absolute paths) into ordered project-relative paths for the details
-// DTO. It returns nil for a single-file or empty selection, where ComposeFileName
-// is authoritative.
+// ComposeSelectionRelativePaths returns a multi-file COMPOSE_FILE selection as
+// ordered project-relative paths; nil for single or empty selections.
func ComposeSelectionRelativePaths(projectPath string, selection []string) []string {
if len(selection) <= 1 {
return nil
diff --git a/backend/internal/project/children/lifecycle/helpers_nonunix.go b/backend/internal/project/children/lifecycle/helpers_nonunix.go
index e823dce0c..afaf0ec3c 100644
--- a/backend/internal/project/children/lifecycle/helpers_nonunix.go
+++ b/backend/internal/project/children/lifecycle/helpers_nonunix.go
@@ -6,7 +6,7 @@ import (
"fmt"
)
-func describeLifecyclePathAccessInternal(projectPath, resolvedScriptPath string) string {
+func describeLifecyclePathAccess(projectPath, resolvedScriptPath string) string {
return fmt.Sprintf("Project path=%q, resolved script path=%q. Ensure the Arcane process can traverse every parent "+
"directory and inspect the script. A script being executable is not sufficient when ownership, ACLs, "+
"or mount permissions block access.", projectPath,
diff --git a/backend/internal/project/children/lifecycle/helpers_unix.go b/backend/internal/project/children/lifecycle/helpers_unix.go
index 30465d118..ec15dc0d9 100644
--- a/backend/internal/project/children/lifecycle/helpers_unix.go
+++ b/backend/internal/project/children/lifecycle/helpers_unix.go
@@ -10,7 +10,7 @@ import (
"syscall"
)
-func describeLifecyclePathAccessInternal(projectPath, resolvedScriptPath string) string {
+func describeLifecyclePathAccess(projectPath, resolvedScriptPath string) string {
var lines []string
lines = append(lines,
@@ -22,7 +22,31 @@ func describeLifecyclePathAccessInternal(projectPath, resolvedScriptPath string)
"Path inspection:",
)
- for _, candidate := range lifecycleDiagnosticPathsInternal(projectPath, resolvedScriptPath) {
+ // Walk from the project root down to the script; fall back to the two
+ // endpoints when the script resolves outside the project.
+ paths := []string{projectPath, resolvedScriptPath}
+ absProject, projectErr := filepath.Abs(projectPath)
+ absScript, scriptErr := filepath.Abs(resolvedScriptPath)
+ relative, relErr := filepath.Rel(absProject, absScript)
+ switch {
+ case projectErr != nil:
+ case scriptErr != nil:
+ paths = []string{absProject, resolvedScriptPath}
+ case relErr != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)):
+ paths = []string{absProject, absScript}
+ default:
+ paths = []string{absProject}
+ current := absProject
+ for component := range strings.SplitSeq(relative, string(filepath.Separator)) {
+ if component == "" || component == "." {
+ continue
+ }
+ current = filepath.Join(current, component)
+ paths = append(paths, current)
+ }
+ }
+
+ for _, candidate := range paths {
// os.* rather than acfs: diagnostics walk arbitrary ancestor directories
// of a user-configured path, so no confinement root exists for them.
info, err := os.Lstat(candidate)
@@ -36,13 +60,23 @@ func describeLifecyclePathAccessInternal(projectPath, resolvedScriptPath string)
owner = fmt.Sprintf("uid=%d gid=%d", stat.Uid, stat.Gid)
}
+ fileType := "other"
+ switch {
+ case info.Mode()&os.ModeSymlink != 0:
+ fileType = "symlink"
+ case info.IsDir():
+ fileType = "directory"
+ case info.Mode().IsRegular():
+ fileType = "regular"
+ }
+
lines = append(lines, fmt.Sprintf(
" %q: mode=%s permissions=%04o %s type=%s",
candidate,
info.Mode(),
info.Mode().Perm(),
owner,
- lifecycleFileTypeInternal(info),
+ fileType,
))
}
@@ -53,46 +87,3 @@ func describeLifecyclePathAccessInternal(projectPath, resolvedScriptPath string)
return strings.Join(lines, " ")
}
-
-func lifecycleDiagnosticPathsInternal(projectPath, resolvedScriptPath string) []string {
- absProject, err := filepath.Abs(projectPath)
- if err != nil {
- return []string{projectPath, resolvedScriptPath}
- }
-
- absScript, err := filepath.Abs(resolvedScriptPath)
- if err != nil {
- return []string{absProject, resolvedScriptPath}
- }
-
- relative, err := filepath.Rel(absProject, absScript)
- if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
- return []string{absProject, absScript}
- }
-
- paths := []string{absProject}
- current := absProject
-
- for component := range strings.SplitSeq(relative, string(filepath.Separator)) {
- if component == "" || component == "." {
- continue
- }
- current = filepath.Join(current, component)
- paths = append(paths, current)
- }
-
- return paths
-}
-
-func lifecycleFileTypeInternal(info os.FileInfo) string {
- switch {
- case info.Mode()&os.ModeSymlink != 0:
- return "symlink"
- case info.IsDir():
- return "directory"
- case info.Mode().IsRegular():
- return "regular"
- default:
- return "other"
- }
-}
diff --git a/backend/internal/project/children/lifecycle/helpers_unix_test.go b/backend/internal/project/children/lifecycle/helpers_unix_test.go
index 1a82b7f36..4ffdd491b 100644
--- a/backend/internal/project/children/lifecycle/helpers_unix_test.go
+++ b/backend/internal/project/children/lifecycle/helpers_unix_test.go
@@ -20,7 +20,7 @@ func TestDescribeLifecyclePathAccess_ReportsPathMetadata(t *testing.T) {
require.NoError(t, os.MkdirAll(scriptsDir, 0o750))
require.NoError(t, os.WriteFile(scriptPath, []byte("#!/bin/sh\n"), 0o755))
- got := describeLifecyclePathAccessInternal(dir, scriptPath)
+ got := describeLifecyclePathAccess(dir, scriptPath)
assert.Contains(t, got, "Arcane process identity: uid=")
assert.Contains(t, got, "Path inspection:")
@@ -49,22 +49,10 @@ func TestDescribeLifecyclePathAccess_StopsAtFirstInaccessibleComponent(t *testin
_ = os.Chmod(blockedDir, 0o700)
})
- got := describeLifecyclePathAccessInternal(dir, scriptPath)
+ got := describeLifecyclePathAccess(dir, scriptPath)
assert.Contains(t, got, fmt.Sprintf("%q: mode=", blockedDir))
assert.Contains(t, got, fmt.Sprintf("%q: lstat ", scriptPath))
assert.Contains(t, got, "permission denied")
assert.NotContains(t, got, fmt.Sprintf("%q: mode=", scriptPath))
}
-
-func TestLifecycleDiagnosticPaths_RemainsInsideProject(t *testing.T) {
- dir := t.TempDir()
- scriptPath := filepath.Join(dir, "scripts", "pre-deploy.sh")
-
- got := lifecycleDiagnosticPathsInternal(dir, scriptPath)
-
- require.Len(t, got, 3)
- assert.Equal(t, dir, got[0])
- assert.Equal(t, filepath.Join(dir, "scripts"), got[1])
- assert.Equal(t, scriptPath, got[2])
-}
diff --git a/backend/internal/project/children/lifecycle/service.go b/backend/internal/project/children/lifecycle/service.go
index eb597b1cb..f9f1ac7f4 100644
--- a/backend/internal/project/children/lifecycle/service.go
+++ b/backend/internal/project/children/lifecycle/service.go
@@ -24,10 +24,8 @@ import (
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/mount"
"github.com/moby/moby/client"
- "github.com/samber/mo"
"go.getarcane.app/acfs"
"go.getarcane.app/docker"
- "go.getarcane.app/kit/pkg"
"go.getarcane.app/kit/pkg/capture"
dockerInternal "github.com/getarcaneapp/arcane/backend/v2/internal/docker"
@@ -45,13 +43,30 @@ type Service struct {
imageService *image.ImageService
}
+const (
+ // lifecycleWorkspaceMount is where the project dir is mounted; scripts run there.
+ lifecycleWorkspaceMount = "/workspace"
+ // lifecycleMaxOutputBytes caps retained stdout/stderr; the full stream is still consumed.
+ lifecycleMaxOutputBytes = 16 * 1024
+ // lifecycleStreamDrainTimeout bounds the post-exit log drain, matching vulnerability scanning.
+ lifecycleStreamDrainTimeout = 30 * time.Second
+
+ // Last-run status values written to GitOpsSync.PreDeployLastRunStatus.
+ LifecycleStatusSuccess = "success"
+ LifecycleStatusFailed = "failed"
+ LifecycleStatusTimeout = "timeout"
+)
+
+// lifecycleEnvKeyRegex enforces POSIX-style env keys in configured Env and script stdout.
+var lifecycleEnvKeyRegex = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
+
func New(settingsService *settings.SettingsService, dockerService *dockerInternal.DockerClientService, imageService *image.ImageService) *Service {
return &Service{settingsService: settingsService, dockerService: dockerService, imageService: imageService}
}
-// markTruncatedInternal returns the captured output, appending a truncation
-// marker when the capture hit its byte cap, matching what the GitOps UI shows.
-func MarkTruncated(c truncatableCaptureInternal) string {
+// markTruncated returns the captured output with a marker when the cap was hit,
+// matching what the GitOps UI shows.
+func markTruncated(c *capture.Capture) string {
out := c.String()
if c.Truncated() {
out += "\n...<truncated>"
@@ -59,20 +74,10 @@ func MarkTruncated(c truncatableCaptureInternal) string {
return out
}
-// truncatableCaptureInternal is satisfied by the capped build log capture. It is
-// declared locally so the lifecycle service depends on the shared capped-output
-// writer's behaviour, not on build-domain types.
-type truncatableCaptureInternal interface {
- String() string
- Truncated() bool
-}
-
-// drainLifecycleLogsInternal waits for the log copy goroutine to finish with
-// a bounded deadline, then force-closes the stream. Mirrors the trivy
-// pattern, which exists to tolerate Docker variants that don't EOF cleanly
-// when a container exits.
-func DrainLifecycleLogs(ctx context.Context, logsCancel context.CancelFunc, logs io.ReadCloser, logDone <-chan error) {
- timer := time.NewTimer(LifecycleStreamDrainTimeout)
+// drainLifecycleLogs waits a bounded time for the log copy to finish, then
+// force-closes the stream for Docker variants that don't EOF on exit.
+func drainLifecycleLogs(ctx context.Context, logsCancel context.CancelFunc, logs io.ReadCloser, logDone <-chan error) {
+ timer := time.NewTimer(lifecycleStreamDrainTimeout)
defer timer.Stop()
select {
case <-logDone:
@@ -83,37 +88,6 @@ func DrainLifecycleLogs(ctx context.Context, logsCancel context.CancelFunc, logs
_ = logs.Close()
}
-const (
- // Lifecycle hook configuration limits and conventions.
- // lifecycleWorkspaceMount is the in-container path the project dir is
- // bind-mounted to. Scripts run with this as their working dir.
- LifecycleWorkspaceMount = "/workspace"
- // lifecycleMaxOutputBytes caps the stdout/stderr we retain on the
- // GitOpsSync row. The full stream is still consumed; the tail is dropped.
- LifecycleMaxOutputBytes = 16 * 1024
- // lifecycleStreamDrainTimeout bounds how long we wait for the log copy
- // goroutine to drain after the container exits, before force-closing.
- // Mirrors the value used by vulnerability scanning for the same purpose.
- LifecycleStreamDrainTimeout = 30 * time.Second
-
- // Last-run status values written to GitOpsSync.PreDeployLastRunStatus.
- LifecycleStatusSuccess = "success"
- LifecycleStatusFailed = "failed"
- LifecycleStatusTimeout = "timeout"
-)
-
-func RemoveLifecycleContainer(ctx context.Context, dockerClient *client.Client, containerID string, apiTimeoutSec int) {
- if dockerClient == nil || containerID == "" {
- return
- }
- cleanupCtx := context.WithoutCancel(ctx)
- cleanupCtx, cleanupCancel := context.WithTimeout(cleanupCtx, timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
- defer cleanupCancel()
- if _, err := dockerClient.ContainerRemove(cleanupCtx, containerID, client.ContainerRemoveOptions{Force: true}); err != nil && !errdefs.IsNotFound(err) {
- slog.WarnContext(cleanupCtx, "failed to remove lifecycle container", "containerId", containerID, "error", err)
- }
-}
-
func CombineLifecycleOutput(stdout, stderr string) string {
stdout = strings.TrimRight(stdout, "\n")
stderr = strings.TrimRight(stderr, "\n")
@@ -129,53 +103,12 @@ func CombineLifecycleOutput(stdout, stderr string) string {
}
}
-func LifecycleStatusForResult(exitCode int64, runErr error) string {
- if runErr != nil {
- return kit.Ternary(errors.Is(runErr, context.DeadlineExceeded), LifecycleStatusTimeout, LifecycleStatusFailed)
- }
- return kit.Ternary(exitCode != 0, LifecycleStatusFailed, LifecycleStatusSuccess)
-}
-
-func BuildLifecycleMounts(workspace *mount.Mount, extras []lifecycletype.ExtraMount) []mount.Mount {
- mounts := make([]mount.Mount, 0, 1+len(extras))
- // The project directory is mounted read-write so scripts can write
- // artifacts the deploy then consumes — e.g. `sops -d secrets.enc.env > .env`.
- // Anything written persists on the host until the next sync overwrites it.
- // The workspace mount itself is built by MountForSubpath
- // so it carries the right Type (bind or volume) and any required
- // VolumeOptions.Subpath.
- mounts = append(mounts, *workspace)
- for _, m := range extras {
- mounts = append(mounts, mount.Mount{
- Type: mount.TypeBind,
- Source: m.Source,
- Target: m.Target,
- ReadOnly: m.Readonly,
- })
- }
- return mounts
-}
-
-func EnvMapToSlice(env map[string]string) []string {
- if len(env) == 0 {
- return nil
- }
- out := make([]string, 0, len(env))
- for k, v := range env {
- out = append(out, k+"="+v)
- }
- return out
-}
-
-// parseKeyValueEnvInternal parses stdout as a strict newline-separated list of
-// KEY=VALUE pairs and returns them as a map. Blank lines and lines starting
-// with '#' (after trimming leading whitespace) are ignored. Anything else is
-// rejected — we'd rather fail a deploy than silently merge garbage into the
-// compose env.
+// ParseKeyValueEnv parses stdout as strict KEY=VALUE lines, skipping blanks and
+// '#' comments; anything else fails the deploy rather than polluting the env.
func ParseKeyValueEnv(stdout string) (map[string]string, error) {
env := map[string]string{}
scanner := bufio.NewScanner(strings.NewReader(stdout))
- scanner.Buffer(make([]byte, 0, 64*1024), LifecycleMaxOutputBytes)
+ scanner.Buffer(make([]byte, 0, 64*1024), lifecycleMaxOutputBytes)
lineNum := 0
for scanner.Scan() {
@@ -191,7 +124,7 @@ func ParseKeyValueEnv(stdout string) (map[string]string, error) {
}
key := line[:idx]
value := line[idx+1:]
- if !LifecycleEnvKeyRegex.MatchString(key) {
+ if !lifecycleEnvKeyRegex.MatchString(key) {
return nil, fmt.Errorf("line %d: invalid env key %q", lineNum, key)
}
env[key] = value
@@ -202,24 +135,8 @@ func ParseKeyValueEnv(stdout string) (map[string]string, error) {
return env, nil
}
-// lifecycleEnvKeyRegex enforces POSIX-style identifier syntax for env keys
-// both in admin-configured Env and in scripts' KEY=VALUE stdout capture.
-var LifecycleEnvKeyRegex = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
-
-// RunnerImage prefers the sync's configured runner image over the
-// lifecycleDefaultRunnerImage setting.
-func (s *Service) RunnerImage(ctx context.Context, configured *string) string {
- if runnerImage := strings.TrimSpace(mo.PointerToOption(configured).OrEmpty()); runnerImage != "" {
- return runnerImage
- }
- return strings.TrimSpace(s.settingsService.GetStringSetting(ctx, "lifecycleDefaultRunnerImage", "alpine:latest"))
-}
-
-// RunScript performs the docker run + log capture + wait.
-// On the happy path it returns stdout, stderr, the script's exit code and a
-// nil error. context.DeadlineExceeded from the per-run timeout is wrapped and
-// returned as the error so callers can distinguish a timeout from a non-zero
-// exit.
+// RunScript runs the script in a runner container and returns its output and exit code.
+// A per-run timeout is returned wrapping context.DeadlineExceeded, distinct from a non-zero exit.
func (s *Service) RunScript(
ctx context.Context,
runnerImage string,
@@ -236,47 +153,54 @@ func (s *Service) RunScript(
return "", "", 0, fmt.Errorf("failed to connect to Docker: %w", dErr)
}
- if ensureRunnerImageErr := s.ensureRunnerImageInternal(ctx, dockerClient, runnerImage, actor); ensureRunnerImageErr != nil {
- return "", "", 0, fmt.Errorf("failed to ensure runner image %s: %w", runnerImage, ensureRunnerImageErr)
+ // Pull a missing runner image through the image service so registry
+ // credentials and the dockerImagePullTimeout setting apply.
+ if _, inspectErr := dockerClient.ImageInspect(ctx, runnerImage); inspectErr != nil {
+ if s.imageService == nil {
+ return "", "", 0, fmt.Errorf("failed to ensure runner image %s: image service is unavailable", runnerImage)
+ }
+ pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(s.settingsService.GetSettingsConfig().DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull))
+ pullErr := s.imageService.PullImage(pullCtx, runnerImage, io.Discard, actor, nil)
+ pullTimedOut := errors.Is(pullCtx.Err(), context.DeadlineExceeded)
+ pullCancel()
+ if pullErr != nil && pullTimedOut {
+ return "", "", 0, fmt.Errorf("failed to ensure runner image %s: runner image pull timed out for %s (increase dockerImagePullTimeout setting if needed)", runnerImage, runnerImage)
+ }
+ if pullErr != nil {
+ return "", "", 0, fmt.Errorf("failed to ensure runner image %s: pull runner image %s: %w", runnerImage, runnerImage, pullErr)
+ }
}
- // Resolve the workspace mount. When Arcane runs inside a container whose
- // /app/data is backed by a named volume, a plain bind-mount of the
- // translated host path (e.g. /var/lib/docker/volumes/.../_data/projects/X)
- // is unreliable — Docker Desktop on WSL2 refuses it outright, and any
- // daemon with non-trivial volume storage may behave differently. Using
- // the named volume directly with VolumeOptions.Subpath sidesteps the
- // translation entirely. For host-bind /app/data the helper returns a
- // plain bind that points at the right host subdir. If Arcane is running
- // on the host (no container inspect available), fall back to a bind on
- // the project path as-is.
+ // MountForSubpath mounts a volume-backed /app/data via VolumeOptions.Subpath
+ // (translated host binds fail on e.g. WSL2); on the host, bind projectPath as-is.
var workspaceMount *mount.Mount
if inspect, inspectErr := libarcane.InspectCurrentArcaneContainer(ctx, dockerClient); inspectErr != nil {
slog.WarnContext(ctx, "failed to derive workspace mount; falling back to bind on project path", "projectPath", projectPath, "error", inspectErr)
} else {
- workspaceMount = docker.MountForSubpath(inspect.Mounts, projectPath, LifecycleWorkspaceMount)
+ workspaceMount = docker.MountForSubpath(inspect.Mounts, projectPath, lifecycleWorkspaceMount)
}
if workspaceMount == nil {
- workspaceMount = &mount.Mount{Type: mount.TypeBind, Source: projectPath, Target: LifecycleWorkspaceMount}
+ workspaceMount = &mount.Mount{Type: mount.TypeBind, Source: projectPath, Target: lifecycleWorkspaceMount}
+ }
+ // The workspace is read-write so scripts can write artifacts the deploy consumes.
+ mounts := make([]mount.Mount, 0, 1+len(extraMounts))
+ mounts = append(mounts, *workspaceMount)
+ for _, m := range extraMounts {
+ mounts = append(mounts, mount.Mount{Type: mount.TypeBind, Source: m.Source, Target: m.Target, ReadOnly: m.Readonly})
+ }
+ var env []string
+ for k, v := range hookEnv {
+ env = append(env, k+"="+v)
}
- // Cmd is the script path alone — no interpreter wrapper. The script's
- // shebang selects the interpreter (which must exist in the runner image),
- // and the file must be executable on the host (git preserves +x through
- // clone, so a committed +x script works transparently). This keeps
- // Arcane out of the language-choice business and matches standard
- // docker run semantics.
- //
- // Entrypoint is explicitly cleared because many purpose-built images set
- // ENTRYPOINT to their primary tool (e.g. the official getsops/sops image
- // has ENTRYPOINT=["sops"]). Without this override, our Cmd would become
- // an argument to that tool rather than replacing it.
+ // Cmd is the executable script alone so its shebang picks the interpreter;
+ // Entrypoint is cleared so images like getsops/sops don't treat it as an argument.
config := &container.Config{
Image: runnerImage,
Entrypoint: []string{},
- Cmd: []string{filepath.ToSlash(filepath.Join(LifecycleWorkspaceMount, scriptPath))},
- WorkingDir: LifecycleWorkspaceMount,
- Env: EnvMapToSlice(hookEnv),
+ Cmd: []string{filepath.ToSlash(filepath.Join(lifecycleWorkspaceMount, scriptPath))},
+ WorkingDir: lifecycleWorkspaceMount,
+ Env: env,
AttachStdout: true,
AttachStderr: true,
Tty: false,
@@ -284,15 +208,10 @@ func (s *Service) RunScript(
libarcane.InternalResourceLabel: "true",
},
}
- // no-new-privileges blocks the script (or anything it spawns) from
- // gaining capabilities via setuid binaries inside the runner image.
- // CapDrop ALL removes the default capability set Docker grants to root
- // in a container (NET_RAW, NET_BIND_SERVICE, SETUID, etc.) — a hook
- // script decrypting secrets or generating config has no need for any
- // of them, and dropping them takes the most-common privilege-escalation
- // primitives off the table even if a malicious script gets in.
+ // no-new-privileges and CapDrop ALL take setuid and default root
+ // capabilities away from the script and anything it spawns.
hostConfig := &container.HostConfig{
- Mounts: BuildLifecycleMounts(workspaceMount, extraMounts),
+ Mounts: mounts,
NetworkMode: container.NetworkMode(cmp.Or(strings.TrimSpace(networkMode), "none")),
SecurityOpt: []string{"no-new-privileges:true"},
CapDrop: []string{"ALL"},
@@ -310,7 +229,14 @@ func (s *Service) RunScript(
return "", "", 0, fmt.Errorf("create lifecycle container: %w", err)
}
containerID := resp.ID
- defer RemoveLifecycleContainer(ctx, dockerClient, containerID, apiTimeoutSec)
+ defer func() {
+ // Cleanup outlives cancellation so a cancelled run never leaks its container.
+ cleanupCtx, cleanupCancel := context.WithTimeout(context.WithoutCancel(ctx), timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
+ defer cleanupCancel()
+ if _, removeErr := dockerClient.ContainerRemove(cleanupCtx, containerID, client.ContainerRemoveOptions{Force: true}); removeErr != nil && !errdefs.IsNotFound(removeErr) {
+ slog.WarnContext(cleanupCtx, "failed to remove lifecycle container", "containerId", containerID, "error", removeErr)
+ }
+ }()
startCtx, startCancel := context.WithTimeout(ctx, timeouts.GetDuration(apiTimeoutSec, timeouts.DefaultDockerAPI))
defer startCancel()
@@ -329,8 +255,8 @@ func (s *Service) RunScript(
return "", "", 0, fmt.Errorf("stream lifecycle container logs: %w", err)
}
- stdoutBuf := capture.New(LifecycleMaxOutputBytes)
- stderrBuf := capture.New(LifecycleMaxOutputBytes)
+ stdoutBuf := capture.New(lifecycleMaxOutputBytes)
+ stderrBuf := capture.New(lifecycleMaxOutputBytes)
logDone := make(chan error, 1)
go func() {
_, copyErr := stdcopy.StdCopy(stdoutBuf, stderrBuf, logs)
@@ -347,64 +273,26 @@ func (s *Service) RunScript(
case result := <-waitResp.Result:
exitCode = result.StatusCode
if result.Error != nil && result.Error.Message != "" {
- DrainLifecycleLogs(ctx, logsCancel, logs, logDone)
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), exitCode, fmt.Errorf("lifecycle container reported error: %s", result.Error.Message)
+ drainLifecycleLogs(ctx, logsCancel, logs, logDone)
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), exitCode, fmt.Errorf("lifecycle container reported error: %s", result.Error.Message)
}
case waitErr := <-waitResp.Error:
- DrainLifecycleLogs(ctx, logsCancel, logs, logDone)
+ drainLifecycleLogs(ctx, logsCancel, logs, logDone)
if errors.Is(waitErr, context.DeadlineExceeded) || errors.Is(waitCtx.Err(), context.DeadlineExceeded) {
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), 0, fmt.Errorf("pre-deploy script timed out after %s: %w", timeout, context.DeadlineExceeded)
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), 0, fmt.Errorf("pre-deploy script timed out after %s: %w", timeout, context.DeadlineExceeded)
}
if errors.Is(waitErr, context.Canceled) {
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), 0, fmt.Errorf("pre-deploy script cancelled: %w", waitErr)
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), 0, fmt.Errorf("pre-deploy script cancelled: %w", waitErr)
}
if waitErr != nil {
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), 0, fmt.Errorf("lifecycle container wait failed: %w", waitErr)
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), 0, fmt.Errorf("lifecycle container wait failed: %w", waitErr)
}
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), 0, nil
- }
-
- DrainLifecycleLogs(ctx, logsCancel, logs, logDone)
-
- return MarkTruncated(stdoutBuf), MarkTruncated(stderrBuf), exitCode, nil
-}
-
-// ensureRunnerImageInternal makes sure the runner image is available locally,
-// pulling it on a miss. The pull is delegated to the image service so the
-// configured registry credentials (and its anonymous retry) apply, bounded by
-// the dockerImagePullTimeout setting so operators on slow networks can tune it.
-func (s *Service) ensureRunnerImageInternal(ctx context.Context, dockerClient *client.Client, imageName string, actor user.Actor) error {
- if _, err := dockerClient.ImageInspect(ctx, imageName); err == nil {
- return nil
- }
- if s.imageService == nil {
- return errors.New("image service is unavailable")
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), 0, nil
}
- pullTimeoutSec := s.settingsService.GetSettingsConfig().DockerImagePullTimeout.AsInt()
- pullCtx, pullCancel := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSec, timeouts.DefaultDockerImagePull))
- defer pullCancel()
+ drainLifecycleLogs(ctx, logsCancel, logs, logDone)
- if err := s.imageService.PullImage(pullCtx, imageName, io.Discard, actor, nil); err != nil {
- if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
- return fmt.Errorf("runner image pull timed out for %s (increase dockerImagePullTimeout setting if needed)", imageName)
- }
- return fmt.Errorf("pull runner image %s: %w", imageName, err)
- }
- return nil
-}
-
-// Timeout caps the per-sync timeout at the lifecycleMaxTimeoutSec setting.
-func (s *Service) Timeout(ctx context.Context, perSyncTimeoutSec int) time.Duration {
- timeoutSec := perSyncTimeoutSec
- if timeoutSec <= 0 {
- timeoutSec = lifecycletype.DefaultTimeoutSec
- }
- maxTimeoutSec := s.settingsService.GetIntSetting(ctx, "lifecycleMaxTimeoutSec", lifecycletype.DefaultMaxTimeoutSec)
- if maxTimeoutSec > 0 && timeoutSec > maxTimeoutSec {
- timeoutSec = maxTimeoutSec
- }
- return time.Duration(timeoutSec) * time.Second
+ return markTruncated(stdoutBuf), markTruncated(stderrBuf), exitCode, nil
}
// ValidateScriptPath rejects paths that escape the project directory
@@ -441,7 +329,7 @@ func ValidateScriptPath(ctx context.Context, projectPath, scriptPath string) err
// container run surface any real problem.
slog.WarnContext(ctx, "cannot inspect pre-deploy script as the Arcane user; proceeding, the runner container may still be able to read it",
"scriptPath", scriptPath,
- "detail", describeLifecyclePathAccessInternal(projectPath, absScript),
+ "detail", describeLifecyclePathAccess(projectPath, absScript),
)
return nil
}
diff --git a/backend/internal/project/children/lifecycle/service_test.go b/backend/internal/project/children/lifecycle/service_test.go
index ecb3d032f..b79ba2676 100644
--- a/backend/internal/project/children/lifecycle/service_test.go
+++ b/backend/internal/project/children/lifecycle/service_test.go
@@ -1,8 +1,6 @@
package lifecycle
import (
- "context"
- "errors"
"os"
"path/filepath"
"testing"
@@ -112,13 +110,6 @@ func TestValidateScriptPath_RejectsSymlink(t *testing.T) {
require.Error(t, err)
}
-func TestLifecycleStatusForResult(t *testing.T) {
- assert.Equal(t, LifecycleStatusSuccess, LifecycleStatusForResult(0, nil))
- assert.Equal(t, LifecycleStatusFailed, LifecycleStatusForResult(1, nil))
- assert.Equal(t, LifecycleStatusFailed, LifecycleStatusForResult(0, errors.New("boom")))
- assert.Equal(t, LifecycleStatusTimeout, LifecycleStatusForResult(0, context.DeadlineExceeded))
-}
-
func TestCombineLifecycleOutput(t *testing.T) {
cases := []struct {
stdout, stderr, want string
diff --git a/backend/internal/project/children/listing/service.go b/backend/internal/project/children/listing/service.go
index ba0e320c5..833c8aeac 100644
--- a/backend/internal/project/children/listing/service.go
+++ b/backend/internal/project/children/listing/service.go
@@ -49,9 +49,9 @@ func New(
// Snapshot is the compose container listing shared by
// every row of one list request, grouped once by compose project name.
type Snapshot struct {
- containers []container.Summary
+ Containers []container.Summary
byProject map[string][]container.Summary
- err error
+ Err error
currentContainerID string
currentContainerErr error
}
@@ -61,11 +61,11 @@ func (s *Service) Snapshot(ctx context.Context) Snapshot {
containers, err := s.containers(ctx)
if err != nil {
slog.ErrorContext(ctx, "Failed to list global compose containers", "error", err)
- return Snapshot{err: err}
+ return Snapshot{Err: err}
}
currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
return Snapshot{
- containers: containers,
+ Containers: containers,
byProject: GroupComposeContainersByProject(containers),
currentContainerID: currentContainerID,
currentContainerErr: currentContainerErr,
@@ -73,7 +73,6 @@ func (s *Service) Snapshot(ctx context.Context) Snapshot {
}
// Containers returns the snapshot's compose containers and listing error.
-func (s Snapshot) Containers() ([]container.Summary, error) { return s.containers, s.err }
// ProjectContainers matches project names first, then the working
// directory if it identifies exactly one Compose project group.
@@ -123,7 +122,7 @@ func RuntimeServiceFromContainer(catalog string, c container.Summary, meta proje
health = new("starting")
}
- resolvedIcon := ResolveServiceIcon(catalog, c.Labels, svcName, meta)
+ resolvedIcon := iconcatalog.Resolve(catalog, cmp.Or(projects.FindArcaneIconSet(c.Labels), meta.ServiceIconSets[svcName], meta.ProjectIcon))
return project.RuntimeService{
Name: svcName,
Image: c.Image,
@@ -140,16 +139,6 @@ func RuntimeServiceFromContainer(catalog string, c container.Summary, meta proje
}
}
-// ResolveServiceIcon picks a service icon from its container labels,
-// then the compose metadata's per-service and project-level icon sets.
-func ResolveServiceIcon(catalog string, containerLabels map[string]string, serviceName string, meta projects.ArcaneComposeMetadata) iconcatalog.ResolvedIconSet {
- return iconcatalog.Resolve(catalog, cmp.Or(
- projects.FindArcaneIconSet(containerLabels),
- meta.ServiceIconSets[serviceName],
- meta.ProjectIcon,
- ))
-}
-
// ServiceCounts returns the total and running service counts.
func ServiceCounts(services []project.RuntimeService) (total, running int) {
total = len(services)
@@ -190,18 +179,6 @@ func ProjectStatus(services []project.RuntimeService) string {
return kit.Ternary(stoppedCount > 0, project.StatusStopped, project.StatusUnknown)
}
-// CountStatus adds a project status to the running or stopped totals.
-func CountStatus(status string, running, stopped *int) {
- switch status {
- case project.StatusRunning, project.StatusPartiallyRunning, project.StatusDeploying, project.StatusRestarting:
- *running++
- case project.StatusStopped, project.StatusStopping:
- *stopped++
- case project.StatusUnknown:
- // Don't count unknown
- }
-}
-
// StatusCounts totals archived, running and stopped projects from live
// containers, falling back to stored status when Docker is unavailable.
func (s *Service) StatusCounts(ctx context.Context, records []project.Record) project.StatusCounts {
@@ -218,25 +195,24 @@ func (s *Service) StatusCounts(ctx context.Context, records []project.Record) pr
containers, err := s.containers(ctx)
if err != nil {
slog.ErrorContext(ctx, "Failed to list global compose containers for counts", "error", err)
- for _, p := range active {
- CountStatus(p.Status, &counts.RunningProjects, &counts.StoppedProjects)
- }
- return counts
}
-
containersByProject := GroupComposeContainersByProject(containers)
for _, p := range active {
- projectContainers := ProjectContainers(p, containersByProject)
- services := make([]project.RuntimeService, 0, len(projectContainers))
- for _, c := range projectContainers {
- services = append(services, project.RuntimeService{Status: string(c.State)})
+ status := p.Status
+ if err == nil {
+ projectContainers := ProjectContainers(p, containersByProject)
+ services := make([]project.RuntimeService, 0, len(projectContainers))
+ for _, c := range projectContainers {
+ services = append(services, project.RuntimeService{Status: string(c.State)})
+ }
+ status = kit.Ternary(len(services) > 0, ProjectStatus(services), project.StatusStopped)
}
-
- status := project.StatusStopped
- if len(services) > 0 {
- status = ProjectStatus(services)
+ switch status {
+ case project.StatusRunning, project.StatusPartiallyRunning, project.StatusDeploying, project.StatusRestarting:
+ counts.RunningProjects++
+ case project.StatusStopped, project.StatusStopping:
+ counts.StoppedProjects++
}
- CountStatus(status, &counts.RunningProjects, &counts.StoppedProjects)
}
return counts
}
@@ -261,11 +237,9 @@ func RelativePath(projectsDir, projectPath string) string {
return filepath.ToSlash(relativePath)
}
-// Row builds the fields the list filters, search, and sort
-// read from database columns and the shared container snapshot. Fields that
-// need compose metadata are left for ApplyPresentation. When
-// the container listing failed the row reports an unknown status.
-func Row(projectsDir, catalog string, p project.Record, snapshot Snapshot) project.Details {
+// row builds the fields list filters, search and sort read from database
+// columns and the container snapshot; compose metadata is left for ApplyPresentation.
+func row(projectsDir, catalog string, p project.Record, snapshot Snapshot) project.Details {
var resp project.Details
_ = mapping.MapStruct(p, &resp)
@@ -280,7 +254,7 @@ func Row(projectsDir, catalog string, p project.Record, snapshot Snapshot) proje
// Use DB service count as the source of truth for "Total Services"
// since we are not parsing the YAML here.
resp.ServiceCount = p.ServiceCount
- if snapshot.err != nil {
+ if snapshot.Err != nil {
resp.Status = project.StatusUnknown
return resp
}
@@ -304,24 +278,14 @@ func Row(projectsDir, catalog string, p project.Record, snapshot Snapshot) proje
resp.ServiceCount = len(services)
}
- // Calculate Status using actual container count from Docker rather than the
- // (potentially stale) DB ServiceCount. The DB value can become outdated when
- // a service is removed from the compose file but compose parsing fails during
- // filesystem sync, leaving the old count in the database. This mirrors the
- // logic in calculateProjectStatus and GetProjectDetails, which both use the
- // live container/service list as the source of truth.
- actualServiceCount := len(services)
- if actualServiceCount == 0 {
+ // Status uses the live services, not the possibly stale stored ServiceCount.
+ switch {
+ case runningCount > 0 && runningCount >= len(services):
+ resp.Status = project.StatusRunning
+ case runningCount > 0:
+ resp.Status = project.StatusPartiallyRunning
+ default:
resp.Status = project.StatusStopped
- } else {
- switch {
- case runningCount >= actualServiceCount:
- resp.Status = project.StatusRunning
- case runningCount > 0:
- resp.Status = project.StatusPartiallyRunning
- default:
- resp.Status = project.StatusStopped
- }
}
return resp
@@ -333,7 +297,7 @@ func Rows(projectsDir, catalog string, records []project.Record, snapshot Snapsh
rows := make([]project.Details, len(records))
inferredCounts := make(map[string]int)
for i, p := range records {
- rows[i] = Row(projectsDir, catalog, p, snapshot)
+ rows[i] = row(projectsDir, catalog, p, snapshot)
if p.ServiceCount == 0 && rows[i].ServiceCount > 0 {
inferredCounts[p.ID] = rows[i].ServiceCount
}
@@ -353,7 +317,7 @@ func ApplyPresentation(ctx context.Context, projectsDir, catalog string, records
resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, records[i].Path)
for k := range resp.RuntimeServices {
service := &resp.RuntimeServices[k]
- localIcon := ResolveServiceIcon(catalog, service.ContainerLabels, service.Name, metas[i])
+ localIcon := iconcatalog.Resolve(catalog, cmp.Or(projects.FindArcaneIconSet(service.ContainerLabels), metas[i].ServiceIconSets[service.Name], metas[i].ProjectIcon))
service.IconLightURL, service.IconDarkURL = localIcon.IconLightURL, localIcon.IconDarkURL
}
}
@@ -363,9 +327,11 @@ func ApplyPresentation(ctx context.Context, projectsDir, catalog string, records
func KnownComposeProjectNames(records []project.Record) map[string]struct{} {
known := make(map[string]struct{}, len(records)*2)
for _, p := range records {
- AddKnownComposeProjectName(known, p.Name)
- if p.ComposeProjectName != nil {
- AddKnownComposeProjectName(known, *p.ComposeProjectName)
+ for _, name := range kit.TrimNonEmpty([]string{p.Name, mo.PointerToOption(p.ComposeProjectName).OrEmpty()}) {
+ known[name] = struct{}{}
+ if normalized := projects.NormalizeProjectName(name); normalized != "" {
+ known[normalized] = struct{}{}
+ }
}
}
return known
@@ -419,10 +385,41 @@ func (s *Service) DiscoveredUpdateRows(
return nil
}
- scoped := GetRuntimeContainerUpdateInfoByContainerID(ctx, composeContainers, s.imageService)
+ var scoped map[string]*imagetypes.UpdateInfo
+ if s.imageService != nil {
+ var err error
+ if scoped, err = s.imageService.GetUpdateInfoByContainers(ctx, composeContainers); err != nil {
+ slog.WarnContext(ctx, "failed to fetch discovered project tag updates", "error", err)
+ scoped = nil
+ }
+ }
rows := make([]project.Details, 0, len(containersByProject))
for projectName, projectContainers := range containersByProject {
- runtimeServices := BuildDiscoveredRuntimeServices(projectContainers, iconCatalog)
+ // One runtime service per distinct service name and image.
+ runtimeServices := make([]project.RuntimeService, 0, len(projectContainers))
+ seenServices := make(map[string]struct{}, len(projectContainers))
+ for _, c := range projectContainers {
+ imageRef := strings.TrimSpace(c.Image)
+ serviceName := cmp.Or(docker.ComposeServiceLabel(c.Labels), c.ID)
+ key := serviceName + "\x00" + imageRef
+ if _, exists := seenServices[key]; exists || imageRef == "" {
+ continue
+ }
+ seenServices[key] = struct{}{}
+ resolvedIcon := iconcatalog.Resolve(iconCatalog, projects.FindArcaneIconSet(c.Labels))
+ runtimeServices = append(runtimeServices, project.RuntimeService{
+ Name: serviceName,
+ Image: imageRef,
+ Status: string(c.State),
+ ContainerID: c.ID,
+ ImageID: c.ImageID,
+ ContainerLabels: c.Labels,
+ ContainerName: docker.ContainerNameFromNames(c.Names),
+ Ports: projects.FormatDockerPorts(c.Ports),
+ IconLightURL: resolvedIcon.IconLightURL,
+ IconDarkURL: resolvedIcon.IconDarkURL,
+ })
+ }
imageRefs := projects.ImageRefsFromRuntimeServices(runtimeServices)
checkServices := make([]project.RuntimeService, 0, len(projectContainers))
for _, c := range projectContainers {
@@ -433,11 +430,16 @@ func (s *Service) DiscoveredUpdateRows(
continue
}
- runningCount := 0
- for _, runtimeService := range runtimeServices {
- if runtimeService.Status == "running" {
- runningCount++
- }
+ serviceCount, runningCount := ServiceCounts(runtimeServices)
+ // Unlike tracked rows, a discovered project without services is unknown.
+ status := project.StatusStopped
+ switch {
+ case serviceCount == 0:
+ status = project.StatusUnknown
+ case runningCount >= serviceCount:
+ status = project.StatusRunning
+ case runningCount > 0:
+ status = project.StatusPartiallyRunning
}
lastCheckedAt := ""
@@ -449,8 +451,8 @@ func (s *Service) DiscoveredUpdateRows(
ID: "compose:" + projectName,
Name: projectName,
Path: "",
- Status: discoveredStatusInternal(len(runtimeServices), runningCount),
- ServiceCount: len(runtimeServices),
+ Status: status,
+ ServiceCount: serviceCount,
RunningCount: runningCount,
IsDiscovered: true,
CreatedAt: lastCheckedAt,
@@ -463,22 +465,40 @@ func (s *Service) DiscoveredUpdateRows(
return rows
}
-func discoveredStatusInternal(serviceCount, runningCount int) string {
- switch {
- case serviceCount == 0:
- return project.StatusUnknown
- case runningCount >= serviceCount:
- return project.StatusRunning
- case runningCount > 0:
- return project.StatusPartiallyRunning
- default:
- return project.StatusStopped
+func ApplyProjectTagsDBFilter(query *gorm.DB, filterValue string) *gorm.DB {
+ var names []string
+ for value := range strings.SplitSeq(filterValue, ",") {
+ if normalized, err := projects.NormalizeProjectTag(value); err == nil {
+ names = append(names, normalized)
+ }
+ }
+ names = kit.Unique(names)
+ if len(names) == 0 {
+ return query
}
+ return query.Where("EXISTS (SELECT 1 FROM project_tags WHERE project_tags.project_id = projects.id AND project_tags.name IN ?)", names)
}
-// PaginationConfig searches, sorts and filters list rows by their derived fields.
-func PaginationConfig() pagination.Config[project.Details] {
- return pagination.Config[project.Details]{
+func GroupComposeContainersByProject(containers []container.Summary) map[string][]container.Summary {
+ containersByProject := make(map[string][]container.Summary)
+ for _, c := range containers {
+ projectName := docker.ComposeProjectLabel(c.Labels)
+ if projectName != "" {
+ containersByProject[projectName] = append(containersByProject[projectName], c)
+ }
+ }
+ return containersByProject
+}
+
+// Page searches, orders and paginates rows by their derived fields and returns
+// the page indexes of tracked rows still needing enrichment.
+func Page(items []project.Details, params pagination.QueryParams, tracked func(id string) bool) (pagination.FilterResult[project.Details], []int) {
+ // Tags are filtered in the database query.
+ if _, exists := params.Filters["tags"]; exists {
+ params.Filters = maps.Clone(params.Filters)
+ delete(params.Filters, "tags")
+ }
+ config := pagination.Config[project.Details]{
SearchAccessors: []pagination.SearchAccessor[project.Details]{
func(p project.Details) (string, error) { return p.Name, nil },
func(p project.Details) (string, error) { return p.Path, nil },
@@ -494,252 +514,69 @@ func PaginationConfig() pagination.Config[project.Details] {
},
},
SortBindings: []pagination.SortBinding[project.Details]{
+ {Key: "name", Fn: func(a, b project.Details) int { return strings.Compare(a.Name, b.Name) }},
+ {Key: "status", Fn: func(a, b project.Details) int { return strings.Compare(a.Status, b.Status) }},
+ {Key: "serviceCount", Fn: func(a, b project.Details) int { return cmp.Compare(a.ServiceCount, b.ServiceCount) }},
+ {Key: "path", Fn: func(a, b project.Details) int { return strings.Compare(a.RelativePath, b.RelativePath) }},
{
- Key: "name",
+ Key: "createdAt",
Fn: func(a, b project.Details) int {
- return strings.Compare(a.Name, b.Name)
+ at, aerr := time.Parse(time.RFC3339, a.CreatedAt)
+ bt, berr := time.Parse(time.RFC3339, b.CreatedAt)
+ if aerr != nil || berr != nil {
+ return strings.Compare(a.CreatedAt, b.CreatedAt)
+ }
+ return at.Compare(bt)
},
},
+ },
+ FilterAccessors: []pagination.FilterAccessor[project.Details]{
{
Key: "status",
- Fn: func(a, b project.Details) int {
- return strings.Compare(a.Status, b.Status)
+ Fn: func(p project.Details, filterValue string) bool {
+ return strings.EqualFold(strings.TrimSpace(p.Status), strings.TrimSpace(filterValue))
},
},
{
- Key: "serviceCount",
- Fn: func(a, b project.Details) int {
- if a.ServiceCount < b.ServiceCount {
- return -1
+ Key: "updates",
+ Fn: func(p project.Details, filterValue string) bool {
+ status := "unknown"
+ if p.UpdateInfo != nil && strings.TrimSpace(p.UpdateInfo.Status) != "" {
+ status = p.UpdateInfo.Status
}
- return kit.Ternary(a.ServiceCount > b.ServiceCount, 1, 0)
+ return strings.EqualFold(strings.TrimSpace(status), strings.TrimSpace(filterValue))
},
},
{
- Key: "path",
- Fn: func(a, b project.Details) int {
- return strings.Compare(a.RelativePath, b.RelativePath)
+ Key: "archived",
+ Fn: func(p project.Details, filterValue string) bool {
+ if strings.EqualFold(strings.TrimSpace(filterValue), "all") {
+ return true
+ }
+ archived, _ := kit.ParseBool(filterValue)
+ return p.IsArchived == archived
},
},
{
- Key: "createdAt",
- Fn: func(a, b project.Details) int {
- at, aerr := time.Parse(time.RFC3339, a.CreatedAt)
- bt, berr := time.Parse(time.RFC3339, b.CreatedAt)
- if aerr != nil || berr != nil {
- return strings.Compare(a.CreatedAt, b.CreatedAt)
+ Key: "label",
+ NoSplit: true,
+ Fn: func(p project.Details, filterValue string) bool {
+ key, value, hasValue := strings.Cut(filterValue, "=")
+ key = strings.TrimSpace(key)
+ if key == "" {
+ return true
}
- if at.Before(bt) {
- return -1
+ for _, service := range p.RuntimeServices {
+ if actual, ok := service.ContainerLabels[key]; ok && (!hasValue || actual == value) {
+ return true
+ }
}
- return kit.Ternary(at.After(bt), 1, 0)
+ return false
},
},
},
- FilterAccessors: []pagination.FilterAccessor[project.Details]{
- BuildProjectStatusFilterAccessor(),
- BuildProjectUpdatesFilterAccessor(),
- BuildProjectArchivedFilterAccessor(),
- BuildProjectLabelFilterAccessor(),
- },
- }
-}
-
-func BuildProjectArchivedFilterAccessor() pagination.FilterAccessor[project.Details] {
- return pagination.FilterAccessor[project.Details]{
- Key: "archived",
- Fn: func(p project.Details, filterValue string) bool {
- if strings.EqualFold(strings.TrimSpace(filterValue), "all") {
- return true
- }
- archived, _ := kit.ParseBool(filterValue)
- return p.IsArchived == archived
- },
}
-}
-
-func BuildProjectUpdatesFilterAccessor() pagination.FilterAccessor[project.Details] {
- return pagination.FilterAccessor[project.Details]{
- Key: "updates",
- Fn: func(p project.Details, filterValue string) bool {
- status := "unknown"
- if p.UpdateInfo != nil && strings.TrimSpace(p.UpdateInfo.Status) != "" {
- status = p.UpdateInfo.Status
- }
- return strings.EqualFold(strings.TrimSpace(status), strings.TrimSpace(filterValue))
- },
- }
-}
-
-func BuildProjectStatusFilterAccessor() pagination.FilterAccessor[project.Details] {
- return pagination.FilterAccessor[project.Details]{
- Key: "status",
- Fn: func(p project.Details, filterValue string) bool {
- return strings.EqualFold(strings.TrimSpace(p.Status), strings.TrimSpace(filterValue))
- },
- }
-}
-
-func BuildProjectLabelFilterAccessor() pagination.FilterAccessor[project.Details] {
- return pagination.FilterAccessor[project.Details]{
- Key: "label",
- NoSplit: true,
- Fn: func(p project.Details, filterValue string) bool {
- key, value, hasValue := strings.Cut(filterValue, "=")
- key = strings.TrimSpace(key)
- if key == "" {
- return true
- }
- for _, service := range p.RuntimeServices {
- if actual, ok := service.ContainerLabels[key]; ok && (!hasValue || actual == value) {
- return true
- }
- }
- return false
- },
- }
-}
-
-func BuildDiscoveredRuntimeServices(containers []container.Summary, iconCatalog string) []project.RuntimeService {
- runtimeServices := make([]project.RuntimeService, 0, len(containers))
- seenServices := make(map[string]struct{}, len(containers))
- for _, c := range containers {
- imageRef := strings.TrimSpace(c.Image)
- if imageRef == "" {
- continue
- }
-
- serviceName := cmp.Or(docker.ComposeServiceLabel(c.Labels), c.ID)
- key := serviceName + "\x00" + imageRef
- if _, exists := seenServices[key]; exists {
- continue
- }
- seenServices[key] = struct{}{}
-
- containerName := docker.ContainerNameFromNames(c.Names)
-
- resolvedIcon := iconcatalog.Resolve(iconCatalog, projects.FindArcaneIconSet(c.Labels))
- runtimeServices = append(runtimeServices, project.RuntimeService{
- Name: serviceName,
- Image: imageRef,
- Status: string(c.State),
- ContainerID: c.ID,
- ImageID: c.ImageID,
- ContainerLabels: c.Labels,
- ContainerName: containerName,
- Ports: projects.FormatDockerPorts(c.Ports),
- IconLightURL: resolvedIcon.IconLightURL,
- IconDarkURL: resolvedIcon.IconDarkURL,
- })
- }
-
- return runtimeServices
-}
-
-func GetRuntimeContainerUpdateInfoByContainerID(ctx context.Context, containers []container.Summary, imageService *image.ImageService) map[string]*imagetypes.UpdateInfo {
- if imageService == nil || len(containers) == 0 {
- return nil
- }
- scoped, err := imageService.GetUpdateInfoByContainers(ctx, containers)
- if err != nil {
- slog.WarnContext(ctx, "failed to fetch discovered project tag updates", "error", err)
- return nil
- }
- return scoped
-}
-
-func AddKnownComposeProjectName(known map[string]struct{}, name string) {
- name = strings.TrimSpace(name)
- if name == "" {
- return
- }
-
- known[name] = struct{}{}
- if normalized := projects.NormalizeProjectName(name); normalized != "" {
- known[normalized] = struct{}{}
- }
-}
-
-func ShouldIncludeDiscoveredComposeProjectUpdates(params pagination.QueryParams) bool {
- if params.Filters == nil {
- return false
- }
-
- return strings.EqualFold(strings.TrimSpace(params.Filters["updates"]), "has_update") && strings.TrimSpace(params.Filters["tags"]) == ""
-}
-
-func WithoutProjectDBFilters(params pagination.QueryParams) pagination.QueryParams {
- if _, exists := params.Filters["tags"]; !exists {
- return params
- }
- params.Filters = maps.Clone(params.Filters)
- delete(params.Filters, "tags")
- return params
-}
-
-func ApplyProjectSearchDBFilter(query *gorm.DB, term string) *gorm.DB {
- searchPattern := "%" + strings.TrimSpace(term) + "%"
- return query.Where(
- "name LIKE ? OR path LIKE ? OR status LIKE ? OR COALESCE(dir_name, '') LIKE ? OR EXISTS (SELECT 1 FROM project_tags WHERE project_tags.project_id = projects.id AND LOWER(project_tags.name) LIKE ?)",
- searchPattern, searchPattern, searchPattern, searchPattern, "%"+strings.ToLower(strings.TrimSpace(term))+"%",
- )
-}
-
-func NormalizeTagFilterValues(filterValue string) []string {
- result := make([]string, 0)
- for value := range strings.SplitSeq(filterValue, ",") {
- if normalized, err := projects.NormalizeProjectTag(value); err == nil {
- result = append(result, normalized)
- }
- }
- return kit.Unique(result)
-}
-
-func ApplyProjectTagsDBFilter(query *gorm.DB, filterValue string) *gorm.DB {
- names := NormalizeTagFilterValues(filterValue)
- if len(names) == 0 {
- return query
- }
- return query.Where("EXISTS (SELECT 1 FROM project_tags WHERE project_tags.project_id = projects.id AND project_tags.name IN ?)", names)
-}
-
-func ApplyProjectArchivedDBFilter(query *gorm.DB, filterValue string) *gorm.DB {
- if strings.EqualFold(strings.TrimSpace(filterValue), "all") {
- return query
- }
- archived, _ := kit.ParseBool(filterValue)
- return query.Where("is_archived = ?", archived)
-}
-
-func GroupComposeContainersByProject(containers []container.Summary) map[string][]container.Summary {
- containersByProject := make(map[string][]container.Summary)
- for _, c := range containers {
- projectName := docker.ComposeProjectLabel(c.Labels)
- if projectName != "" {
- containersByProject[projectName] = append(containersByProject[projectName], c)
- }
- }
- return containersByProject
-}
-
-// ClampDerivedLimit bounds the page size of in-memory filtered lists. An exact
-// -1 is the public "all" contract used by the table page-size selector.
-func ClampDerivedLimit(params pagination.QueryParams) pagination.QueryParams {
- switch {
- case params.Limit == -1:
- case params.Limit <= 0:
- params.Limit = 20
- case params.Limit > 100:
- params.Limit = 100
- }
- return params
-}
-
-// Page searches, orders and paginates rows by their derived fields and
-// returns the page indexes of tracked rows, which still need enrichment.
-// Discovered compose rows are built complete.
-func Page(items []project.Details, params pagination.QueryParams, tracked func(id string) bool) (pagination.FilterResult[project.Details], []int) {
- result := PaginationConfig().SearchOrderAndPaginate(items, WithoutProjectDBFilters(params))
+ result := config.SearchOrderAndPaginate(items, params)
pageIndexes := make([]int, 0, len(result.Items))
for i, item := range result.Items {
if tracked(item.ID) {
diff --git a/backend/internal/project/children/listing/service_test.go b/backend/internal/project/children/listing/service_test.go
index f21366dee..5f0dd967c 100644
--- a/backend/internal/project/children/listing/service_test.go
+++ b/backend/internal/project/children/listing/service_test.go
@@ -1,6 +1,7 @@
package listing
import (
+ "context"
"errors"
"path/filepath"
"testing"
@@ -61,21 +62,17 @@ func TestCalculateProjectStatus(t *testing.T) {
}
}
-func TestIncrementStatusCounts(t *testing.T) {
- running := 0
- stopped := 0
+func TestStatusCounts_FallsBackToStoredStatus(t *testing.T) {
+ svc := New(func(context.Context) ([]container.Summary, error) { return nil, errors.New("docker unavailable") }, nil, nil)
- CountStatus(project.StatusRunning, &running, &stopped)
- assert.Equal(t, 1, running)
- assert.Equal(t, 0, stopped)
+ counts := svc.StatusCounts(t.Context(), []project.Record{
+ {Status: project.StatusRunning},
+ {Status: project.StatusStopped},
+ {Status: project.StatusUnknown},
+ {Status: project.StatusRunning, IsArchived: true},
+ })
- CountStatus(project.StatusStopped, &running, &stopped)
- assert.Equal(t, 1, running)
- assert.Equal(t, 1, stopped)
-
- CountStatus(project.StatusUnknown, &running, &stopped)
- assert.Equal(t, 1, running)
- assert.Equal(t, 1, stopped)
+ assert.Equal(t, project.StatusCounts{TotalProjects: 4, ArchivedProjects: 1, RunningProjects: 1, StoppedProjects: 1}, counts)
}
func TestMapProjectToDto_SetsRedeployDisabledFromRuntimeServices(t *testing.T) {
@@ -162,7 +159,7 @@ func TestMapProjectToDto_SetsRedeployDisabledFromRuntimeServices(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.labels[api.WorkingDirLabel] = projectPath
- details := Row(filepath.Dir(projectPath), iconcatalog.DefaultCatalog, proj, Snapshot{byProject: map[string][]container.Summary{
+ details := row(filepath.Dir(projectPath), iconcatalog.DefaultCatalog, proj, Snapshot{byProject: map[string][]container.Summary{
"arcane": {
{
ID: tt.containerID,
@@ -208,7 +205,7 @@ func TestProjectListRow_SeedsHasBuildDirectiveFromPersistedRefs(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := project.Record{ID: tt.name, Name: tt.name, Path: t.TempDir(), UpdatedAt: &now, BuildImageRefsJSON: tt.buildImageRefsJSON}
- assert.Equal(t, tt.want, Row(projectsDirectory, iconcatalog.DefaultCatalog, p, Snapshot{}).HasBuildDirective)
+ assert.Equal(t, tt.want, row(projectsDirectory, iconcatalog.DefaultCatalog, p, Snapshot{}).HasBuildDirective)
})
}
}
diff --git a/backend/internal/project/children/sync/service.go b/backend/internal/project/children/sync/service.go
index 0d951c1df..a60e5bb8f 100644
--- a/backend/internal/project/children/sync/service.go
+++ b/backend/internal/project/children/sync/service.go
@@ -12,6 +12,7 @@ import (
"strings"
"github.com/getarcaneapp/arcane/types/v2/project"
+ "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
)
@@ -88,31 +89,6 @@ func ResolveStoredEffectiveEnvContent(state projects.ProjectEnvState) (string, e
return state.DirectContent, nil
}
-// cleanupWouldMassWipeInternal reports whether the pending deletions look like an
-// accidental mass wipe rather than legitimate removals. It engages when a single
-// pass would prune more than one project AND more than half of the cleanup
-// candidates — so the table cannot be near-emptied at once (e.g. when the projects
-// directory is unmounted or mis-mapped and every path goes missing), no matter how
-// few projects the deployment has. A single removal is always allowed: it is
-// indistinguishable from a legitimate "deleted my only project" and is not a mass
-// wipe. When the guard engages it logs a WARN pointing the operator at the likely
-// volume/mount misconfiguration and the caller skips every deletion in the pass.
-func CleanupWouldMassWipe(ctx context.Context, candidates, deleteCount int, projectsDir string) bool {
- if deleteCount <= 1 || deleteCount*2 <= candidates {
- return false
- }
-
- slog.WarnContext(ctx,
- "skipping project cleanup: this reconcile would delete most projects in a single pass, which usually "+
- "means the projects directory is empty, unmounted, or mis-mapped; preserving DB records — check the "+
- "projects volume is mounted and mapped correctly",
- "wouldDelete", deleteCount,
- "cleanupCandidates", candidates,
- "projectsDir", projectsDir,
- )
- return true
-}
-
// EffectiveEnvContentForUpdate returns the env content a project update keeps
// when the caller supplied none.
func EffectiveEnvContentForUpdate(projectPath string, envContent *string) (*string, error) {
@@ -120,20 +96,12 @@ func EffectiveEnvContentForUpdate(projectPath string, envContent *string) (*stri
return envContent, nil
}
- state, err := projects.ReadProjectEnvState(projectPath)
- if err != nil {
- return nil, fmt.Errorf("read project env state: %w", err)
- }
-
- effectiveContent, err := ResolveStoredEffectiveEnvContent(state)
+ // A sync without git env content resolves exactly the stored effective content.
+ update, err := PrepareGitSyncEnvUpdate(projectPath, nil)
if err != nil {
return nil, err
}
- if effectiveContent == "" && !state.HasEffective && !state.HasGitSource && !state.HasOverride {
- return nil, nil
- }
-
- return &effectiveContent, nil
+ return update.EffectiveContent, nil
}
// EnsureEffectiveEnvFile rebuilds .env from the managed env sources.
@@ -173,7 +141,7 @@ func PrepareGitSyncEnvUpdate(projectPath string, gitEnvContent *string) (GitSync
}
update := GitSyncEnvUpdate{
- state: state,
+ State: state,
gitEnvContent: gitEnvContent,
}
@@ -185,107 +153,82 @@ func PrepareGitSyncEnvUpdate(projectPath string, gitEnvContent *string) (GitSync
if effectiveContent == "" && !state.HasEffective && !state.HasGitSource && !state.HasOverride {
return update, nil
}
- update.effectiveContent = &effectiveContent
+ update.EffectiveContent = &effectiveContent
return update, nil
}
- overrideContent, err := resolveOverrideContentForGitSyncInternal(state, *gitEnvContent)
+ switch {
+ case state.HasGitSource:
+ update.overrideContent, err = projects.BuildOverrideEnvContent(state.GitContent, state.OverrideContent)
+ case state.HasOverride:
+ storedContent, resolveErr := ResolveStoredEffectiveEnvContent(state)
+ if resolveErr != nil {
+ return GitSyncEnvUpdate{}, resolveErr
+ }
+ update.overrideContent, err = projects.BuildOverrideEnvContent(*gitEnvContent, storedContent)
+ case strings.TrimSpace(state.DirectContent) != "":
+ update.overrideContent, err = projects.BuildAdditiveOverrideEnvContent(*gitEnvContent, state.DirectContent)
+ }
if err != nil {
- return GitSyncEnvUpdate{}, err
+ return GitSyncEnvUpdate{}, fmt.Errorf("build override env content: %w", err)
}
- update.overrideContent = overrideContent
- effectiveContent, err := projects.BuildEffectiveEnvContent(*gitEnvContent, overrideContent)
+ effectiveContent, err := projects.BuildEffectiveEnvContent(*gitEnvContent, update.overrideContent)
if err != nil {
return GitSyncEnvUpdate{}, fmt.Errorf("build effective env content: %w", err)
}
- update.effectiveContent = &effectiveContent
+ update.EffectiveContent = &effectiveContent
return update, nil
}
-func resolveOverrideContentForGitSyncInternal(state projects.ProjectEnvState, gitEnvContent string) (string, error) {
- switch {
- case state.HasGitSource:
- overrideContent, err := projects.BuildOverrideEnvContent(state.GitContent, state.OverrideContent)
- if err != nil {
- return "", fmt.Errorf("build override env content: %w", err)
- }
- return overrideContent, nil
- case state.HasOverride:
- effectiveContent, err := ResolveStoredEffectiveEnvContent(state)
- if err != nil {
- return "", err
- }
- overrideContent, err := projects.BuildOverrideEnvContent(gitEnvContent, effectiveContent)
- if err != nil {
- return "", fmt.Errorf("build override env content: %w", err)
- }
- return overrideContent, nil
- case strings.TrimSpace(state.DirectContent) != "":
- overrideContent, err := projects.BuildAdditiveOverrideEnvContent(gitEnvContent, state.DirectContent)
- if err != nil {
- return "", fmt.Errorf("build override env content: %w", err)
- }
- return overrideContent, nil
- default:
- return "", nil
- }
-}
-
// GitSyncEnvUpdate is the resolved three-file env change for one git sync.
type GitSyncEnvUpdate struct {
- state projects.ProjectEnvState
+ State projects.ProjectEnvState
gitEnvContent *string
overrideContent string
- effectiveContent *string
+ EffectiveContent *string
}
// PersistGitSyncEnvFiles writes a prepared env merge.
func PersistGitSyncEnvFiles(ctx context.Context, projectPath, projectsDirectory string, update GitSyncEnvUpdate) error {
if update.gitEnvContent == nil {
- if update.state.HasGitSource {
+ if update.State.HasGitSource {
if err := projects.RemoveProjectFile(ctx, projectsDirectory, projectPath, projects.GitSourceEnvFileName); err != nil {
return err
}
}
- if update.state.HasOverride {
+ if update.State.HasOverride {
if err := projects.RemoveProjectFile(ctx, projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
return err
}
}
- if update.effectiveContent != nil || update.state.HasEffective || update.state.HasGitSource || update.state.HasOverride {
- effectiveContent := ""
- if update.effectiveContent != nil {
- effectiveContent = *update.effectiveContent
- }
- return projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.EffectiveEnvFileName, update.state.EffectiveUnreadable, effectiveContent)
+ if update.EffectiveContent != nil || update.State.HasEffective || update.State.HasGitSource || update.State.HasOverride {
+ return projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.EffectiveEnvFileName, update.State.EffectiveUnreadable, kit.FromPtr(update.EffectiveContent))
}
- if update.state.EffectiveUnreadable {
+ if update.State.EffectiveUnreadable {
slog.WarnContext(ctx, "skipping permission-locked .env file; leaving it untouched", "projectPath", projectPath)
return nil
}
return projects.EnsureEnvFile(ctx, projectsDirectory, projectPath)
}
- if update.effectiveContent == nil {
+ if update.EffectiveContent == nil {
return errors.New("missing effective env content for git sync update")
}
- if err := projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.EffectiveEnvFileName, update.state.EffectiveUnreadable, *update.effectiveContent); err != nil {
+ if err := projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.EffectiveEnvFileName, update.State.EffectiveUnreadable, *update.EffectiveContent); err != nil {
return err
}
- if err := projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.GitSourceEnvFileName, update.state.GitSourceUnreadable, *update.gitEnvContent); err != nil {
+ if err := projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.GitSourceEnvFileName, update.State.GitSourceUnreadable, *update.gitEnvContent); err != nil {
return err
}
- return projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.OverrideEnvFileName, update.state.OverrideUnreadable, update.overrideContent)
+ return projects.WriteManagedEnvFile(ctx, projectsDirectory, projectPath, projects.OverrideEnvFileName, update.State.OverrideUnreadable, update.overrideContent)
}
// EffectiveContent is the merged .env content, or nil when none is kept.
-func (u GitSyncEnvUpdate) EffectiveContent() *string { return u.effectiveContent }
// HadGitSource reports whether the project tracked a git env source before.
-func (u GitSyncEnvUpdate) HadGitSource() bool { return u.state.HasGitSource }
// ApplyGitSyncEnv applies the managed three-file environment merge and returns
// the effective content before and after the update.
@@ -294,14 +237,10 @@ func ApplyGitSyncEnv(ctx context.Context, projectPath, projectsDirectory string,
if err != nil {
return "", "", fmt.Errorf("failed to resolve git env state: %w", err)
}
- before = update.state.DirectContent
- if update.effectiveContent != nil {
- after = *update.effectiveContent
- }
if persistErr := PersistGitSyncEnvFiles(ctx, projectPath, projectsDirectory, update); persistErr != nil {
return "", "", fmt.Errorf("failed to sync git env files: %w", persistErr)
}
- return before, after, nil
+ return update.State.DirectContent, kit.FromPtr(update.EffectiveContent), nil
}
// LoadComposeMetadata loads a discovered project's compose file once and
@@ -312,10 +251,8 @@ func LoadComposeMetadata(ctx context.Context, dirPath, dirName, projectsDirector
ResolvedProjectName: normName,
}
- // First, try loading without forcing a project name so compose-go can
- // resolve COMPOSE_PROJECT_NAME from the .env file. If this fails (e.g.
- // no .env and directory name is not a valid compose project name), fall
- // back to the normalized directory name.
+ // Load unnamed first so COMPOSE_PROJECT_NAME from .env wins; fall back to
+ // the normalized directory name when that fails.
proj, _, err := projects.LoadComposeProjectFromDir(ctx, dirPath, "", projectsDirectory, autoInjectEnv, pathMapper)
if err != nil {
proj, _, err = projects.LoadComposeProjectFromDir(ctx, dirPath, normName, projectsDirectory, autoInjectEnv, pathMapper)
@@ -331,8 +268,7 @@ func LoadComposeMetadata(ctx context.Context, dirPath, dirName, projectsDirector
meta.ResolvedProjectName = proj.Name
}
- // If compose-go resolved a different name (from COMPOSE_PROJECT_NAME),
- // store it so we can match containers correctly.
+ // Keep a COMPOSE_PROJECT_NAME override so containers match.
if proj.Name != "" && proj.Name != normName {
meta.ComposeProjectName = new(proj.Name)
}
diff --git a/backend/internal/project/children/sync/service_test.go b/backend/internal/project/children/sync/service_test.go
index cf25d8344..1734be05d 100644
--- a/backend/internal/project/children/sync/service_test.go
+++ b/backend/internal/project/children/sync/service_test.go
@@ -23,7 +23,7 @@ func TestPersistGitSyncEnvFiles_UsesPreparedState(t *testing.T) {
update, err := PrepareGitSyncEnvUpdate(projectPath, new("BASE=git-updated\nTOKEN=git\nREMOTE=1\n"))
require.NoError(t, err)
- require.NotNil(t, update.EffectiveContent())
+ require.NotNil(t, update.EffectiveContent)
require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=unexpected\n"), 0o600))
diff --git a/backend/internal/project/children/tags/service.go b/backend/internal/project/children/tags/service.go
index 52f5f1f84..f873e4665 100644
--- a/backend/internal/project/children/tags/service.go
+++ b/backend/internal/project/children/tags/service.go
@@ -9,6 +9,7 @@ import (
"strings"
"github.com/getarcaneapp/arcane/types/v2/project"
+ "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
)
@@ -76,10 +77,12 @@ func ApplyUpdate(store Store, projectID, name string, color project.TagColor, at
if count >= projects.ProjectTagsPerSourceLimit {
return fmt.Errorf("a project cannot have more than %d UI tags", projects.ProjectTagsPerSourceLimit)
}
- resolvedColor, err := resolveColorInternal(store, name, color)
+ // One color per tag name across projects; the normalized color only seeds new names.
+ storedColor, found, err := store.StoredColor(name)
if err != nil {
- return err
+ return fmt.Errorf("resolve project tag color: %w", err)
}
+ resolvedColor := kit.Ternary(found, storedColor, color)
if attachErr := store.InsertIgnoringConflict(project.TagAssignment{ProjectID: projectID, Name: name, Source: project.TagSourceUI, Color: resolvedColor}); attachErr != nil {
return fmt.Errorf("attach UI project tag: %w", attachErr)
}
@@ -111,9 +114,14 @@ func AttachInitial(store Store, projectID string, uiTags []string, colors map[st
}
rows := make([]project.TagAssignment, 0, len(uiTags))
for _, tag := range uiTags {
- color, err := resolveColorInternal(store, tag, colors[tag])
+ color, found, err := store.StoredColor(tag)
if err != nil {
- return err
+ return fmt.Errorf("resolve project tag color: %w", err)
+ }
+ if !found {
+ if color, err = projects.NormalizeProjectTagColor(colors[tag]); err != nil {
+ return err
+ }
}
rows = append(rows, project.TagAssignment{ProjectID: projectID, Name: tag, Source: project.TagSourceUI, Color: color})
}
@@ -123,18 +131,6 @@ func AttachInitial(store Store, projectID string, uiTags []string, colors map[st
return nil
}
-// resolveColorInternal keeps one color per tag name across projects.
-func resolveColorInternal(store Store, name string, fallback project.TagColor) (project.TagColor, error) {
- color, found, err := store.StoredColor(name)
- if err != nil {
- return "", fmt.Errorf("resolve project tag color: %w", err)
- }
- if found {
- return color, nil
- }
- return projects.NormalizeProjectTagColor(fallback)
-}
-
// Group merges stored assignments into effective tags per project, sorted by
// name with the UI source first.
func Group(rows []project.TagAssignment) map[string][]project.Tag {
@@ -158,43 +154,6 @@ func Group(rows []project.TagAssignment) map[string][]project.Tag {
return result
}
-// Options returns one option per tag name from assignments ordered by name.
-func Options(rows []project.TagAssignment) []project.TagOption {
- options := make([]project.TagOption, 0)
- for _, row := range rows {
- if len(options) > 0 && options[len(options)-1].Name == row.Name {
- continue
- }
- options = append(options, project.TagOption{Name: row.Name, Color: row.Color})
- }
- return options
-}
-
-// TrackedProjectIDs lists the rows that are stored projects.
-func TrackedProjectIDs(items []project.Details) []string {
- projectIDs := make([]string, 0, len(items))
- for _, item := range items {
- if item.ID != "" && !item.IsDiscovered && !strings.HasPrefix(item.ID, "compose:") {
- projectIDs = append(projectIDs, item.ID)
- }
- }
- return projectIDs
-}
-
-func ExcludeComposeOwnedUITags(uiTags []string, composeTags []project.TagOption) []string {
- composeOwned := make(map[string]struct{}, len(composeTags))
- for _, tag := range composeTags {
- composeOwned[tag.Name] = struct{}{}
- }
- result := make([]string, 0, len(uiTags))
- for _, tag := range uiTags {
- if _, exists := composeOwned[tag]; !exists {
- result = append(result, tag)
- }
- }
- return result
-}
-
func NormalizeProjectTagColors(colors map[string]project.TagColor) (map[string]project.TagColor, error) {
result := make(map[string]project.TagColor, len(colors))
for name, color := range colors {
diff --git a/backend/internal/project/children/update/service.go b/backend/internal/project/children/update/service.go
index 6d8c35bb0..7ba432cfa 100644
--- a/backend/internal/project/children/update/service.go
+++ b/backend/internal/project/children/update/service.go
@@ -68,28 +68,21 @@ func New(
// SyncState holds the paths an in-flight rename protects from filesystem sync.
type SyncState struct {
- skipDiscoveredPaths map[string]struct{}
- protectSeenPaths map[string]struct{}
+ SkipDiscoveredPaths map[string]struct{}
+ ProtectSeenPaths map[string]struct{}
}
-// SkipDiscoveredPath reports whether a discovered directory is a rename target.
-func (s SyncState) SkipDiscoveredPath(path string) bool {
- _, ok := s.skipDiscoveredPaths[filepath.Clean(path)]
- return ok
-}
-
-// MarkProtectedPathsSeen keeps rename sources from being cleaned up.
-func (s SyncState) MarkProtectedPathsSeen(seen map[string]struct{}) {
- for path := range s.protectSeenPaths {
- seen[path] = struct{}{}
- }
+// composeImageEdit is an image scalar's source byte span and its replacement text.
+type composeImageEdit struct {
+ start, end int
+ text []byte
}
// SyncState collects the paths pending renames protect during filesystem sync.
func (s *Service) SyncState(ctx context.Context) SyncState {
state := SyncState{
- skipDiscoveredPaths: make(map[string]struct{}),
- protectSeenPaths: make(map[string]struct{}),
+ SkipDiscoveredPaths: make(map[string]struct{}),
+ ProtectSeenPaths: make(map[string]struct{}),
}
if s == nil || s.kv == nil {
return state
@@ -111,10 +104,10 @@ func (s *Service) SyncState(ctx context.Context) SyncState {
continue
}
if oldPath := strings.TrimSpace(journal.OldPath); oldPath != "" {
- state.protectSeenPaths[filepath.Clean(oldPath)] = struct{}{}
+ state.ProtectSeenPaths[filepath.Clean(oldPath)] = struct{}{}
}
if newPath := strings.TrimSpace(journal.NewPath); newPath != "" {
- state.skipDiscoveredPaths[filepath.Clean(newPath)] = struct{}{}
+ state.SkipDiscoveredPaths[filepath.Clean(newPath)] = struct{}{}
}
}
@@ -177,14 +170,14 @@ func (s *Service) WriteJournal(ctx context.Context, journal *project.RenameJourn
return nil
}
-func (s *Service) clearJournalInternal(ctx context.Context, projectID string) error {
+func (s *Service) clearJournal(ctx context.Context, projectID string) error {
if s == nil || s.kv == nil || strings.TrimSpace(projectID) == "" {
return nil
}
return s.kv.Delete(ctx, project.RenameJournalKeyPrefix+projectID)
}
-func (s *Service) writeRollbackCleanupInternal(ctx context.Context, journal *project.RenameJournal) error {
+func (s *Service) writeRollbackCleanup(ctx context.Context, journal *project.RenameJournal) error {
if s == nil || s.kv == nil || journal == nil || strings.TrimSpace(journal.ProjectID) == "" || len(journal.Volumes) == 0 {
return nil
}
@@ -208,7 +201,7 @@ func (s *Service) writeRollbackCleanupInternal(ctx context.Context, journal *pro
return nil
}
-func (s *Service) clearRollbackCleanupInternal(ctx context.Context, projectID string) error {
+func (s *Service) clearRollbackCleanup(ctx context.Context, projectID string) error {
if s == nil || s.kv == nil || strings.TrimSpace(projectID) == "" {
return nil
}
@@ -233,12 +226,26 @@ func (s *Service) RecoverAll(ctx context.Context) error {
recoverErr = errors.Join(recoverErr, fmt.Errorf("decode project rename journal %s: %w", entry.Key, unmarshalErr))
continue
}
- if recoverProjectRenameJournalErr := s.recoverJournalInternal(ctx, &journal); recoverProjectRenameJournalErr != nil {
- recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename journal %s: %w", entry.Key, recoverProjectRenameJournalErr))
+ if journalErr := s.recoverJournal(ctx, &journal); journalErr != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename journal %s: %w", entry.Key, journalErr))
+ }
+ }
+
+ cleanups, err := s.kv.ListByPrefix(ctx, project.RenameRollbackCleanupKeyPrefix)
+ if err != nil {
+ return errors.Join(recoverErr, err)
+ }
+ for _, entry := range cleanups {
+ var cleanup project.RenameRollbackCleanup
+ if unmarshalErr := json.Unmarshal([]byte(entry.Value), &cleanup); unmarshalErr != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("decode project rename rollback cleanup %s: %w", entry.Key, unmarshalErr))
continue
}
+ if cleanupErr := s.recoverRollbackCleanup(ctx, &cleanup); cleanupErr != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename rollback cleanup %s: %w", entry.Key, cleanupErr))
+ }
}
- return errors.Join(recoverErr, s.recoverRollbackCleanupsInternal(ctx))
+ return recoverErr
}
// RecoverProject replays one project's pending rename journal.
@@ -256,10 +263,10 @@ func (s *Service) RecoverProject(ctx context.Context, projectID string) error {
if unmarshalErr := json.Unmarshal([]byte(raw), &journal); unmarshalErr != nil {
return fmt.Errorf("decode project rename journal: %w", unmarshalErr)
}
- return s.recoverJournalInternal(ctx, &journal)
+ return s.recoverJournal(ctx, &journal)
}
-func (s *Service) recoverJournalInternal(ctx context.Context, journal *project.RenameJournal) error {
+func (s *Service) recoverJournal(ctx context.Context, journal *project.RenameJournal) error {
if s == nil || journal == nil || strings.TrimSpace(journal.ProjectID) == "" {
return nil
}
@@ -273,37 +280,12 @@ func (s *Service) recoverJournalInternal(ctx context.Context, journal *project.R
return projects.RecoverRenameJournal(ctx, journal, projectCommitted, s.Operations())
}
-func (s *Service) recoverRollbackCleanupsInternal(ctx context.Context) error {
- if s == nil || s.kv == nil {
- return nil
- }
-
- entries, err := s.kv.ListByPrefix(ctx, project.RenameRollbackCleanupKeyPrefix)
- if err != nil {
- return err
- }
-
- var recoverErr error
- for _, entry := range entries {
- var cleanup project.RenameRollbackCleanup
- if unmarshalErr := json.Unmarshal([]byte(entry.Value), &cleanup); unmarshalErr != nil {
- recoverErr = errors.Join(recoverErr, fmt.Errorf("decode project rename rollback cleanup %s: %w", entry.Key, unmarshalErr))
- continue
- }
- if recoverProjectRenameRollbackCleanupErr := s.recoverRollbackCleanupInternal(ctx, &cleanup); recoverProjectRenameRollbackCleanupErr != nil {
- recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename rollback cleanup %s: %w", entry.Key, recoverProjectRenameRollbackCleanupErr))
- continue
- }
- }
- return recoverErr
-}
-
-func (s *Service) recoverRollbackCleanupInternal(ctx context.Context, cleanup *project.RenameRollbackCleanup) error {
+func (s *Service) recoverRollbackCleanup(ctx context.Context, cleanup *project.RenameRollbackCleanup) error {
if s == nil || cleanup == nil || strings.TrimSpace(cleanup.ProjectID) == "" {
return nil
}
if len(cleanup.Volumes) == 0 {
- return s.clearRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ return s.clearRollbackCleanup(ctx, cleanup.ProjectID)
}
name, path, found, stateErr := s.projectState(ctx, cleanup.ProjectID)
@@ -312,18 +294,18 @@ func (s *Service) recoverRollbackCleanupInternal(ctx context.Context, cleanup *p
}
if !found {
slog.WarnContext(ctx, "clearing project rename rollback cleanup because project no longer exists", "projectId", cleanup.ProjectID)
- return s.clearRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ return s.clearRollbackCleanup(ctx, cleanup.ProjectID)
}
if name != cleanup.OldName || filepath.Clean(path) != filepath.Clean(cleanup.OldPath) {
slog.WarnContext(ctx, "clearing project rename rollback cleanup because project state changed", "projectId", cleanup.ProjectID, "projectName", name, "projectPath", path)
- return s.clearRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ return s.clearRollbackCleanup(ctx, cleanup.ProjectID)
}
return projects.CleanupRenameRollbackTargets(ctx, cleanup, s.Operations())
}
-func (s *Service) dockerClientInternal(ctx context.Context, dockerRequired bool) (*client.Client, error) {
+func (s *Service) dockerClient(ctx context.Context, dockerRequired bool) (*client.Client, error) {
if !dockerRequired {
return nil, nil
}
@@ -342,11 +324,11 @@ func (s *Service) dockerClientInternal(ctx context.Context, dockerRequired bool)
// Operations exposes journal persistence to the shared rename engine.
func (s *Service) Operations() project.RenameRecoveryOperations {
return project.RenameRecoveryOperations{
- Docker: s.dockerClientInternal,
+ Docker: s.dockerClient,
WriteJournal: s.WriteJournal,
- ClearJournal: s.clearJournalInternal,
- ClearRollbackCleanup: s.clearRollbackCleanupInternal,
- WriteRollbackCleanup: s.writeRollbackCleanupInternal,
+ ClearJournal: s.clearJournal,
+ ClearRollbackCleanup: s.clearRollbackCleanup,
+ WriteRollbackCleanup: s.writeRollbackCleanup,
RestoreState: s.restoreState,
}
}
@@ -372,7 +354,7 @@ func PersistProjectServiceImages(ctx context.Context, projectPath, logical strin
return nil
}
-func ComposeImageField(node *yaml.Node, key string) *yaml.Node {
+func composeImageField(node *yaml.Node, key string) *yaml.Node {
if node == nil || node.Kind != yaml.MappingNode {
return nil
}
@@ -384,7 +366,7 @@ func ComposeImageField(node *yaml.Node, key string) *yaml.Node {
return nil
}
-func ValidateImageUpdateSource(node *yaml.Node) error {
+func validateImageUpdateSource(node *yaml.Node) error {
if node.Kind == yaml.AliasNode || node.Anchor != "" {
return errors.New("tag updates do not rewrite Compose YAML anchors or aliases; use explicit service images")
}
@@ -396,7 +378,7 @@ func ValidateImageUpdateSource(node *yaml.Node) error {
}
}
for _, child := range node.Content {
- if err := ValidateImageUpdateSource(child); err != nil {
+ if err := validateImageUpdateSource(child); err != nil {
return err
}
}
@@ -416,19 +398,19 @@ func PrepareProjectServiceImages(source []byte, effective *types.Project, change
if len(document.Content) != 1 {
return nil, nil, errors.New("Compose source must contain a mapping") //nolint:staticcheck // Preserve the existing error message.
}
- if err := ValidateImageUpdateSource(document.Content[0]); err != nil {
+ if err := validateImageUpdateSource(document.Content[0]); err != nil {
return nil, nil, err
}
- if ComposeImageField(document.Content[0], "include") != nil {
+ if composeImageField(document.Content[0], "include") != nil {
return nil, nil, errors.New("tag updates do not rewrite Compose includes; update their source manually")
}
- servicesNode := ComposeImageField(document.Content[0], "services")
+ servicesNode := composeImageField(document.Content[0], "services")
if servicesNode == nil || servicesNode.Kind != yaml.MappingNode {
return nil, nil, errors.New("Compose source has no services mapping") //nolint:staticcheck // Preserve the existing error message.
}
serviceNames := make([]string, 0, len(changes))
// Rewrite image scalars in place; re-encoding the node tree drops blank lines and operator formatting.
- edits := make([]composeImageEditInternal, 0, len(changes))
+ edits := make([]composeImageEdit, 0, len(changes))
for name, change := range changes {
service, ok := effective.Services[name]
if !ok {
@@ -441,18 +423,18 @@ func PrepareProjectServiceImages(source []byte, effective *types.Project, change
if refs.NormalizeImageUpdateRef(service.Image) != expected && refs.NormalizeImageUpdateRef(service.Image) != target {
return nil, nil, fmt.Errorf("service %s image changed since update check: expected %s, found %s", name, change.ExpectedRef, service.Image)
}
- serviceNode := ComposeImageField(servicesNode, name)
- if ComposeImageField(serviceNode, "extends") != nil {
+ serviceNode := composeImageField(servicesNode, name)
+ if composeImageField(serviceNode, "extends") != nil {
return nil, nil, fmt.Errorf("tag updates do not rewrite extended service %s; update its source manually", name)
}
- imageNode := ComposeImageField(serviceNode, "image")
+ imageNode := composeImageField(serviceNode, "image")
if imageNode == nil || imageNode.Kind != yaml.ScalarNode || imageNode.Tag != "!!str" {
return nil, nil, fmt.Errorf("service %s requires an explicit image scalar in the authoritative Compose file", name)
}
if !strings.Contains(imageNode.Value, "$") && refs.NormalizeImageUpdateRef(imageNode.Value) != expected && refs.NormalizeImageUpdateRef(imageNode.Value) != target {
return nil, nil, fmt.Errorf("service %s source image changed since Compose was loaded", name)
}
- edit, err := ComposeImageSourceEdit(source, imageNode, change.TargetRef)
+ edit, err := composeImageSourceEdit(source, imageNode, change.TargetRef)
if err != nil {
return nil, nil, fmt.Errorf("service %s: %w", name, err)
}
@@ -461,7 +443,7 @@ func PrepareProjectServiceImages(source []byte, effective *types.Project, change
}
slices.Sort(serviceNames)
// Splice from the end so earlier spans keep their offsets; distinct scalars never overlap.
- slices.SortFunc(edits, func(a, b composeImageEditInternal) int { return b.start - a.start })
+ slices.SortFunc(edits, func(a, b composeImageEdit) int { return b.start - a.start })
updated := slices.Clone(source)
for _, edit := range edits {
updated = slices.Concat(updated[:edit.start], edit.text, updated[edit.end:])
@@ -469,11 +451,11 @@ func PrepareProjectServiceImages(source []byte, effective *types.Project, change
return updated, serviceNames, nil
}
-// composeImageSourceEditInternal finds an image scalar's single-line source span using YAML's line-break rules
+// composeImageSourceEdit finds an image scalar's single-line source span using YAML's line-break rules
// and renders the target in the scalar's original style.
-func ComposeImageSourceEdit(source []byte, node *yaml.Node, target string) (composeImageEditInternal, error) {
+func composeImageSourceEdit(source []byte, node *yaml.Node, target string) (composeImageEdit, error) {
const lineBreaks = "\r\n\u0085\u2028\u2029"
- edit := composeImageEditInternal{start: len(source) - len(bytes.TrimPrefix(source, []byte("\xEF\xBB\xBF")))}
+ edit := composeImageEdit{start: len(source) - len(bytes.TrimPrefix(source, []byte("\xEF\xBB\xBF")))}
for line, column := 1, 1; line < node.Line || (line == node.Line && column < node.Column); column++ {
if edit.start >= len(source) {
return edit, errors.New("image scalar position is outside the Compose source")
@@ -509,14 +491,8 @@ func ComposeImageSourceEdit(source []byte, node *yaml.Node, target string) (comp
return edit, nil
}
-// composeImageEditInternal is an image scalar's source byte span and its replacement text.
-type composeImageEditInternal struct {
- start, end int
- text []byte
-}
-
-// ensureProjectEnvReadableInternal rejects operator-driven file writes into a
-// project whose .env exists but cannot be read by the runtime user.
+// EnsureProjectEnvReadable rejects operator-driven file writes into a project
+// whose .env exists but cannot be read by the runtime user.
func EnsureProjectEnvReadable(ctx context.Context, projectsDirectory, projectPath string) error {
cfgErr := projects.CheckProjectEnvAccess(ctx, projectsDirectory, projectPath)
if cfgErr == nil || !cfgErr.BlocksOperations {
@@ -536,73 +512,62 @@ func EnsureProjectEnvReadable(ctx context.Context, projectsDirectory, projectPat
// ImageChanges discovers newer image tags allowed by each service's update
// policy. GitOps-managed projects cannot have their source edited.
func (s *Service) ImageChanges(ctx context.Context, effective *types.Project, gitOpsManaged bool) (map[string]updatertypes.ServiceImageChange, error) {
+ policy := updater.DefaultLabelPolicy()
changes := make(map[string]updatertypes.ServiceImageChange)
- for _, name := range effective.ServiceNames() {
- change, err := s.imageChangeInternal(ctx, effective.Services[name], gitOpsManaged)
+ for _, key := range effective.ServiceNames() {
+ service := effective.Services[key]
+ name := service.Name
+ configuredPolicy := policy.TagPolicy(service.Labels)
+ if service.Build != nil && (configuredPolicy.Strategy == "" || configuredPolicy.Strategy == "auto") && configuredPolicy.Constraint == "" && configuredPolicy.TagPattern == "" {
+ continue
+ }
+ immutable := refs.IsDigestPinnedReference(service.Image) || refs.IsImageIDLikeReference(service.Image)
+ if configuredPolicy.Strategy == "tag" && immutable {
+ return nil, fmt.Errorf("service %s has an immutable image reference", name)
+ }
+ tagPolicy, err := tagpolicy.Resolve(service.Image, configuredPolicy)
+ if err != nil {
+ return nil, fmt.Errorf("resolve service %s update policy: %w", name, err)
+ }
+ if tagPolicy.Strategy == "digest" {
+ continue
+ }
+ switch {
+ case policy.IsUpdateDisabled(service.Labels):
+ return nil, fmt.Errorf("updates are disabled for service %s", name)
+ case service.Build != nil:
+ return nil, fmt.Errorf("tag discovery is unsupported for locally built service %s", name)
+ case gitOpsManaged:
+ return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")
+ case immutable:
+ return nil, fmt.Errorf("service %s has an immutable image reference", name)
+ }
+ parsed, err := refs.NormalizeReference(service.Image)
+ if err != nil {
+ return nil, fmt.Errorf("parse service %s image: %w", name, err)
+ }
+ if s.registryService == nil {
+ return nil, errors.New("registry service unavailable for tag updates")
+ }
+ credentials, err := s.credentials(ctx)
if err != nil {
return nil, err
}
- if change != nil {
- changes[name] = *change
+ tags, err := s.registryService.ListImageTags(ctx, service.Image, credentials)
+ if err != nil {
+ return nil, fmt.Errorf("list service %s image tags: %w", name, err)
+ }
+ selected, err := tagpolicy.Select(parsed.Tag, tags, tagPolicy)
+ if err != nil {
+ return nil, fmt.Errorf("select service %s image tag: %w", name, err)
+ }
+ if selected != parsed.Tag {
+ changes[key] = updatertypes.ServiceImageChange{ExpectedRef: service.Image, TargetRef: parsed.RegistryHost + "/" + parsed.Repository + ":" + selected}
}
}
return changes, nil
}
-func (s *Service) imageChangeInternal(ctx context.Context, service types.ServiceConfig, gitOpsManaged bool) (*updatertypes.ServiceImageChange, error) {
- policy := updater.DefaultLabelPolicy()
- name := service.Name
- configuredPolicy := policy.TagPolicy(service.Labels)
- if service.Build != nil && (configuredPolicy.Strategy == "" || configuredPolicy.Strategy == "auto") && configuredPolicy.Constraint == "" && configuredPolicy.TagPattern == "" {
- return nil, nil
- }
- if configuredPolicy.Strategy == "tag" && (refs.IsDigestPinnedReference(service.Image) || refs.IsImageIDLikeReference(service.Image)) {
- return nil, fmt.Errorf("service %s has an immutable image reference", name)
- }
- tagPolicy, resolveErr := tagpolicy.Resolve(service.Image, configuredPolicy)
- if resolveErr != nil {
- return nil, fmt.Errorf("resolve service %s update policy: %w", name, resolveErr)
- }
- if tagPolicy.Strategy == "digest" {
- return nil, nil
- }
- if policy.IsUpdateDisabled(service.Labels) {
- return nil, fmt.Errorf("updates are disabled for service %s", name)
- }
- if service.Build != nil {
- return nil, fmt.Errorf("tag discovery is unsupported for locally built service %s", name)
- }
- if gitOpsManaged {
- return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")
- }
- if refs.IsDigestPinnedReference(service.Image) || refs.IsImageIDLikeReference(service.Image) {
- return nil, fmt.Errorf("service %s has an immutable image reference", name)
- }
- parsed, err := refs.NormalizeReference(service.Image)
- if err != nil {
- return nil, fmt.Errorf("parse service %s image: %w", name, err)
- }
- if s.registryService == nil {
- return nil, errors.New("registry service unavailable for tag updates")
- }
- credentials, err := s.credentials(ctx)
- if err != nil {
- return nil, err
- }
- tags, err := s.registryService.ListImageTags(ctx, service.Image, credentials)
- if err != nil {
- return nil, fmt.Errorf("list service %s image tags: %w", name, err)
- }
- selected, err := tagpolicy.Select(parsed.Tag, tags, tagPolicy)
- if err != nil {
- return nil, fmt.Errorf("select service %s image tag: %w", name, err)
- }
- if selected != parsed.Tag {
- return &updatertypes.ServiceImageChange{ExpectedRef: service.Image, TargetRef: parsed.RegistryHost + "/" + parsed.Repository + ":" + selected}, nil
- }
- return nil, nil
-}
-
// ApplyImageChanges rewrites the image fields of the single authoritative
// Compose file and returns the services whose images changed.
func (s *Service) ApplyImageChanges(ctx context.Context, projectPath string, effective *types.Project, changes map[string]updatertypes.ServiceImageChange) ([]string, error) {
diff --git a/backend/internal/project/children/workspace/service.go b/backend/internal/project/children/workspace/service.go
index 7673f4685..0da0c6e5d 100644
--- a/backend/internal/project/children/workspace/service.go
+++ b/backend/internal/project/children/workspace/service.go
@@ -60,7 +60,7 @@ func (s *Service) Read(ctx context.Context, projectPath, composeFileName string,
// File returns one workspace file's content and whether it may be edited.
func (s *Service) File(ctx context.Context, projectPath, composeFileName, relativePath string, owned map[string]struct{}) (*workspacetypes.FileContent, error) {
- rel, fullPath, entry, err := resolvePathInternal(ctx, projectPath, composeFileName, relativePath)
+ rel, fullPath, entry, err := resolvePath(ctx, projectPath, composeFileName, relativePath)
if err != nil {
return nil, err
}
@@ -88,7 +88,7 @@ func (s *Service) File(ctx context.Context, projectPath, composeFileName, relati
}
reader, _, err := acfs.OpenRead(ctx, projectPath, "/"+rel, maxBytes)
if err != nil {
- return nil, ClassifyProjectWorkspaceACFSError(err, "read project workspace file")
+ return nil, classifyACFSError(err, "read project workspace file")
}
defer func() { _ = reader.Close() }()
content, err := io.ReadAll(reader)
@@ -113,7 +113,7 @@ func (s *Service) File(ctx context.Context, projectPath, composeFileName, relati
// Download opens one workspace file for streaming.
func (s *Service) Download(ctx context.Context, projectPath, composeFileName, relativePath string) (io.ReadCloser, int64, string, error) {
- rel, _, entry, err := resolvePathInternal(ctx, projectPath, composeFileName, relativePath)
+ rel, _, entry, err := resolvePath(ctx, projectPath, composeFileName, relativePath)
if err != nil {
return nil, 0, "", err
}
@@ -122,7 +122,7 @@ func (s *Service) Download(ctx context.Context, projectPath, composeFileName, re
}
file, size, err := acfs.OpenRead(ctx, projectPath, "/"+rel, 0)
if err != nil {
- return nil, 0, "", ClassifyProjectWorkspaceACFSError(err, "open project workspace file")
+ return nil, 0, "", classifyACFSError(err, "open project workspace file")
}
return file, size, filepath.Base(rel), nil
}
@@ -137,7 +137,7 @@ func (s *Service) Apply(
) error {
scope := projects.ProjectUpdateBackupScope{}
for _, change := range manifest.FileChanges {
- scope.Paths = append(scope.Paths, WorkspaceChangeTargetPaths(change)...)
+ scope.Paths = append(scope.Paths, changeTargetPaths(change)...)
}
backup, cleanup, err := projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)
if err != nil {
@@ -187,7 +187,8 @@ func OwnedPaths(syncedFiles *string, composePath string) (map[string]struct{}, e
return owned, nil
}
-func resolvePathInternal(ctx context.Context, projectPath, composeFileName, relativePath string) (string, string, types.Entry, error) {
+// resolvePath validates a workspace path outside protected config and stats it.
+func resolvePath(ctx context.Context, projectPath, composeFileName, relativePath string) (string, string, types.Entry, error) {
rel, err := kit.NormalizeRelativePath(relativePath)
if err != nil {
return "", "", types.Entry{}, common.Classify(common.ErrProjectWorkspaceForbidden, fmt.Errorf("invalid project workspace path: %w", err))
@@ -203,11 +204,12 @@ func resolvePathInternal(ctx context.Context, projectPath, composeFileName, rela
if os.IsNotExist(err) {
return "", "", types.Entry{}, common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))
}
- return "", "", types.Entry{}, ClassifyProjectWorkspaceACFSError(err, "inspect project workspace file")
+ return "", "", types.Entry{}, classifyACFSError(err, "inspect project workspace file")
}
return rel, fullPath, entry, nil
}
+// WrapProjectWorkspaceError classifies workspace apply failures.
func WrapProjectWorkspaceError(err error) error {
if err == nil {
return nil
@@ -231,9 +233,8 @@ func WrapProjectWorkspaceError(err error) error {
}
}
-// validateWorkspaceChangesAgainstGitOpsInternal rejects file changes that
-// touch a sync-owned path, directly or by deleting/renaming a folder that
-// still holds one.
+// ValidateWorkspaceChangesAgainstGitOps rejects changes that touch a sync-owned
+// path, directly or by deleting/renaming a folder that still holds one.
func ValidateWorkspaceChangesAgainstGitOps(changes []project.WorkspaceFileChange, owned map[string]struct{}) error {
if len(owned) == 0 {
return nil
@@ -251,7 +252,7 @@ func ValidateWorkspaceChangesAgainstGitOps(changes []project.WorkspaceFileChange
return false
}
for _, change := range changes {
- for _, target := range WorkspaceChangeTargetPaths(change) {
+ for _, target := range changeTargetPaths(change) {
if touchesOwned(target) {
return common.Classify(common.ErrProjectWorkspaceForbidden, fmt.Errorf("%q is managed by git sync and can only be changed in the git repository", target))
}
@@ -260,10 +261,9 @@ func ValidateWorkspaceChangesAgainstGitOps(changes []project.WorkspaceFileChange
return nil
}
-// workspaceChangeTargetPathsInternal lists every normalized project-relative
-// path a workspace file change can create, overwrite or delete. Shared by the
-// backup scope and the GitOps ownership check so the two cannot diverge.
-func WorkspaceChangeTargetPaths(change project.WorkspaceFileChange) []string {
+// changeTargetPaths lists every normalized path a change can create, overwrite or
+// delete; backup scope and GitOps ownership share it so they cannot diverge.
+func changeTargetPaths(change project.WorkspaceFileChange) []string {
rel, err := kit.NormalizeRelativePath(change.RelativePath)
if err != nil {
return nil
@@ -280,11 +280,8 @@ func WorkspaceChangeTargetPaths(change project.WorkspaceFileChange) []string {
return paths
}
-func ClassifyProjectWorkspaceACFSError(err error, operation string) error {
- if err == nil {
- return nil
- }
-
+// classifyACFSError classifies workspace read failures.
+func classifyACFSError(err error, operation string) error {
switch {
case errors.Is(err, acfs.ErrInvalidPath), errors.Is(err, acfs.ErrOutsideRoot), errors.Is(err, acfs.ErrSymlinkLoop), errors.Is(err, acfs.ErrSymlink):
return common.Classify(common.ErrProjectWorkspaceForbidden, fmt.Errorf("%s: %w", operation, err))
diff --git a/backend/internal/project/helpers.go b/backend/internal/project/helpers.go
index 1b8dbf986..19d8ee043 100644
--- a/backend/internal/project/helpers.go
+++ b/backend/internal/project/helpers.go
@@ -20,17 +20,18 @@ import (
"gorm.io/gorm"
"gorm.io/gorm/clause"
- "github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
)
-type buildServiceInternal interface {
+type builder interface {
BuildImage(ctx context.Context, environmentID string, req types.BuildRequest, progressWriter io.Writer, serviceName string, user *usertypes.Actor) (*types.BuildResult, error)
BuildSettings() types.BuildSettings
}
-type projectMetadataEnvInternal struct {
+// projectMetadataEnv carries the request-scoped inputs compose
+// resolution needs beyond the project itself, resolved once per list request.
+type projectMetadataEnv struct {
projectsDirectory string
autoInjectEnv bool
// settings is the snapshot shared by compose loads; nil resolves lazily.
@@ -48,26 +49,17 @@ type projectMetadataEnvInternal struct {
composeFiles map[string]string
}
-func gitOpsSyncIDInternal(proj *Project) string {
+func gitOpsSyncID(proj *Project) string {
if proj == nil || proj.GitOpsManagedBy == nil {
return ""
}
return strings.TrimSpace(*proj.GitOpsManagedBy)
}
-// composeFileInternal memoizes a project's resolved compose file for the
-// request so metadata and update enrichment share one resolution. Only
-// successful resolutions are cached: a failure (for example a transient
-// filesystem or GitOps lookup error) is returned as-is and the next caller
-// resolves again, matching the per-phase retry of the unmemoized flow.
-//
-// The mutex is deliberately not held across resolve: it does filesystem and
-// database work, and holding the lock would serialize the concurrent
-// per-project workers. Callers run one worker per project within a phase and
-// phases run back to back, so the same project is not resolved concurrently;
-// if it ever were, both workers would compute the same path and the duplicate
-// work is harmless.
-func (env *projectMetadataEnvInternal) composeFileInternal(projectID string, resolve func() (string, error)) (string, error) {
+// composeFile memoizes successful compose file resolutions for the request.
+// The lock is not held across resolve, which does I/O; workers resolve
+// distinct projects, so a rare duplicate resolution is harmless.
+func (env *projectMetadataEnv) composeFile(projectID string, resolve func() (string, error)) (string, error) {
if env == nil || projectID == "" {
return resolve()
}
@@ -90,23 +82,14 @@ func (env *projectMetadataEnvInternal) composeFileInternal(projectID string, res
return path, nil
}
-func getProjectsDirectoryOrDefaultInternal(ctx context.Context, cfg *settings.Settings) string {
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(cfg.ProjectsDirectory.Value))
- if err != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", err)
- return "/app/data/projects"
- }
- return projectsDirectory
-}
-
-// composeNameCacheInternal maps normalized compose project names to project
+// composeNameCache maps normalized compose project names to project
// IDs so a name lookup skips the projects table scan.
-type composeNameCacheInternal struct {
+type composeNameCache struct {
mu sync.RWMutex
byName map[string]string
}
-func (c *composeNameCacheInternal) projectIDInternal(normalizedName string) mo.Option[string] {
+func (c *composeNameCache) projectID(normalizedName string) mo.Option[string] {
if normalizedName == "" {
return mo.None[string]()
}
@@ -122,7 +105,7 @@ func (c *composeNameCacheInternal) projectIDInternal(normalizedName string) mo.O
return mo.TupleToOption(projectID, ok)
}
-func (c *composeNameCacheInternal) putInternal(normalizedName, projectID string) {
+func (c *composeNameCache) put(normalizedName, projectID string) {
if normalizedName == "" || projectID == "" {
return
}
@@ -136,7 +119,7 @@ func (c *composeNameCacheInternal) putInternal(normalizedName, projectID string)
c.byName[normalizedName] = projectID
}
-func (c *composeNameCacheInternal) invalidateInternal(normalizedName string) {
+func (c *composeNameCache) invalidate(normalizedName string) {
if normalizedName == "" {
return
}
@@ -147,33 +130,12 @@ func (c *composeNameCacheInternal) invalidateInternal(normalizedName string) {
delete(c.byName, normalizedName)
}
-func (c *composeNameCacheInternal) replaceInternal(byName map[string]string) {
+func (c *composeNameCache) replace(byName map[string]string) {
c.mu.Lock()
c.byName = byName
c.mu.Unlock()
}
-// loadGitOpsSyncForProjectInternal returns the GitOps sync linked to the
-// given project, or nil if the project is not GitOps-managed. A nil sync
-// with nil error is a normal outcome, not a failure.
-func loadGitOpsSyncForProjectInternal(ctx context.Context, db *database.DB, projectID string) (*GitOpsSync, error) {
- if projectID == "" {
- return nil, nil
- }
-
- var syncRecord GitOpsSync
- err := db.WithContext(ctx).
- Where("project_id = ?", projectID).
- First(&syncRecord).Error
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, nil
- }
- if err != nil {
- return nil, err
- }
- return &syncRecord, nil
-}
-
// projectCleanupDecision records a project the reconcile pass intends to delete,
// alongside the reason logged when the deletion is carried out.
type projectCleanupDecision struct {
@@ -181,40 +143,7 @@ type projectCleanupDecision struct {
reason string
}
-func skipProjectCleanupInternal(p Project, seen map[string]struct{}) bool {
- // Skip paths seen in this pass.
- if _, ok := seen[p.Path]; ok {
- return true
- }
-
- // Skip projects whose lifecycle is owned by the gitops system. Their compose
- // files may not exist on disk yet (e.g. during a sync or after an SSH/clone
- // failure) and should never be deleted here.
- return p.GitOpsManagedBy != nil && strings.TrimSpace(*p.GitOpsManagedBy) != ""
-}
-
-// isInternalScratchProjectInternal reports whether a project row was imported from
-// one of Arcane's own scratch directories (project-update preview/backup, or GitOps
-// sync-stage/backup). Such rows are never real user projects — a crash or restart
-// mid-operation can leak the scratch dir, which the filesystem discovery then imports.
-// They are force-removed during cleanup regardless of whether the dir still exists.
-func isInternalScratchProjectInternal(p Project) bool {
- if projects.IsInternalScratchDirName(p.Name) || projects.IsInternalScratchDirName(filepath.Base(p.Path)) {
- return true
- }
- return p.DirName != nil && projects.IsInternalScratchDirName(*p.DirName)
-}
-
-func evaluateProjectPathErrorInternal(ctx context.Context, p Project, err error) mo.Option[projectCleanupDecision] {
- if os.IsNotExist(err) {
- return mo.Some(projectCleanupDecision{project: p, reason: "removed project: directory no longer exists"})
- }
-
- slog.WarnContext(ctx, "stat error during cleanup; keeping DB record", "path", p.Path, "error", err)
- return mo.None[projectCleanupDecision]()
-}
-
-func deleteProjectWithTagsInternal(tx *gorm.DB, projectID string) error {
+func deleteProjectWithTags(tx *gorm.DB, projectID string) error {
if err := tx.Where("project_id = ?", projectID).Delete(&ProjectTag{}).Error; err != nil {
return fmt.Errorf("delete project tags: %w", err)
}
@@ -227,11 +156,11 @@ func deleteProjectWithTagsInternal(tx *gorm.DB, projectID string) error {
return nil
}
-// resolveAuthoritativeProjectNameInternal enforces that a top-level `name:` in
+// resolveAuthoritativeProjectName enforces that a top-level `name:` in
// the compose file is authoritative over the submitted project name. For
// name-only renames, it checks the compose file on disk so the lock can't be
// bypassed via the API.
-func resolveAuthoritativeProjectNameInternal(ctx context.Context, proj *Project, name, composeContent *string) *string {
+func resolveAuthoritativeProjectName(ctx context.Context, proj *Project, name, composeContent *string) *string {
if composeContent != nil {
if yamlName := projects.ComposeContentProjectName(*composeContent); yamlName != "" {
return &yamlName
@@ -248,41 +177,7 @@ func resolveAuthoritativeProjectNameInternal(ctx context.Context, proj *Project,
return name
}
-// gitSyncProjectContentInternal is the effective content compared before and
-// after a git sync apply. Unreadable snapshots always compare as changed.
-type gitSyncProjectContentInternal struct {
- compose, env, override string
- unreadable bool
-}
-
-func projectRenameVolumeMigrationComposeNamesInternal(s *ProjectService, proj *Project, name *string) (string, string, bool) {
- if s == nil || s.dockerService == nil || proj == nil || name == nil {
- return "", "", false
- }
-
- newProjectName := strings.TrimSpace(*name)
- if newProjectName == "" || proj.Name == newProjectName || proj.Status != ProjectStatusStopped {
- return "", "", false
- }
-
- oldComposeName := projects.NormalizeProjectName(proj.Name)
- newComposeName := projects.NormalizeProjectName(newProjectName)
- if oldComposeName == "" || newComposeName == "" || oldComposeName == newComposeName {
- return "", "", false
- }
-
- return oldComposeName, newComposeName, true
-}
-
-func isProjectRenameRequestedInternal(proj *Project, name *string) bool {
- if proj == nil || name == nil {
- return false
- }
- newName := strings.TrimSpace(*name)
- return newName != "" && proj.Name != newName
-}
-
-func withProjectRenameRollbackInternal(ctx context.Context, proj *Project, projectStateCommitted *bool, run func() error) error {
+func withProjectRenameRollback(ctx context.Context, proj *Project, projectStateCommitted *bool, run func() error) error {
originalPath := proj.Path
originalDirName := proj.DirName
@@ -318,8 +213,8 @@ func withProjectRenameRollbackInternal(ctx context.Context, proj *Project, proje
return nil
}
-// projectRecordInternal exposes a stored project's state to child features.
-func projectRecordInternal(p Project) projecttypes.Record {
+// projectRecord exposes a stored project's state to child features.
+func projectRecord(p Project) projecttypes.Record {
return projecttypes.Record{
ID: p.ID,
Name: p.Name,
@@ -339,32 +234,32 @@ func projectRecordInternal(p Project) projecttypes.Record {
}
}
-func projectRecordsInternal(projectsList []Project) []projecttypes.Record {
+func projectRecords(projectsList []Project) []projecttypes.Record {
records := make([]projecttypes.Record, len(projectsList))
for i, p := range projectsList {
- records[i] = projectRecordInternal(p)
+ records[i] = projectRecord(p)
}
return records
}
-// tagStoreInternal persists tag assignments for the tags child inside one transaction.
-type tagStoreInternal struct {
+// tagStore persists tag assignments for the tags child inside one transaction.
+type tagStore struct {
tx *gorm.DB
}
-func (s tagStoreInternal) CountTag(projectID, name string, source projecttypes.TagSource) (int64, error) {
+func (s tagStore) CountTag(projectID, name string, source projecttypes.TagSource) (int64, error) {
var count int64
err := s.tx.Model(&ProjectTag{}).Where("project_id = ? AND name = ? AND source = ?", projectID, name, source).Count(&count).Error
return count, err
}
-func (s tagStoreInternal) CountSource(projectID string, source projecttypes.TagSource) (int64, error) {
+func (s tagStore) CountSource(projectID string, source projecttypes.TagSource) (int64, error) {
var count int64
err := s.tx.Model(&ProjectTag{}).Where("project_id = ? AND source = ?", projectID, source).Count(&count).Error
return count, err
}
-func (s tagStoreInternal) StoredColor(name string) (projecttypes.TagColor, bool, error) {
+func (s tagStore) StoredColor(name string) (projecttypes.TagColor, bool, error) {
var row ProjectTag
err := s.tx.Where("name = ?", name).Order("source DESC, color").First(&row).Error
switch {
@@ -377,34 +272,23 @@ func (s tagStoreInternal) StoredColor(name string) (projecttypes.TagColor, bool,
}
}
-func (s tagStoreInternal) Insert(rows []projecttypes.TagAssignment) error {
- return s.tx.Create(projectTagsInternal(rows)).Error
+func (s tagStore) Insert(rows []projecttypes.TagAssignment) error {
+ tagRows := make([]ProjectTag, 0, len(rows))
+ for _, row := range rows {
+ tagRows = append(tagRows, ProjectTag{ProjectID: row.ProjectID, Name: row.Name, Source: string(row.Source), Color: string(row.Color)})
+ }
+ return s.tx.Create(tagRows).Error
}
-func (s tagStoreInternal) InsertIgnoringConflict(row projecttypes.TagAssignment) error {
- return s.tx.Clauses(clause.OnConflict{DoNothing: true}).Create(projectTagsInternal([]projecttypes.TagAssignment{row})).Error
+func (s tagStore) InsertIgnoringConflict(row projecttypes.TagAssignment) error {
+ tagRow := ProjectTag{ProjectID: row.ProjectID, Name: row.Name, Source: string(row.Source), Color: string(row.Color)}
+ return s.tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&tagRow).Error
}
-func (s tagStoreInternal) DeleteTag(projectID, name string, source projecttypes.TagSource) error {
+func (s tagStore) DeleteTag(projectID, name string, source projecttypes.TagSource) error {
return s.tx.Where("project_id = ? AND name = ? AND source = ?", projectID, name, source).Delete(&ProjectTag{}).Error
}
-func (s tagStoreInternal) DeleteSource(projectID string, source projecttypes.TagSource) error {
+func (s tagStore) DeleteSource(projectID string, source projecttypes.TagSource) error {
return s.tx.Where("project_id = ? AND source = ?", projectID, source).Delete(&ProjectTag{}).Error
}
-
-func projectTagsInternal(rows []projecttypes.TagAssignment) []ProjectTag {
- tagRows := make([]ProjectTag, 0, len(rows))
- for _, row := range rows {
- tagRows = append(tagRows, ProjectTag{ProjectID: row.ProjectID, Name: row.Name, Source: string(row.Source), Color: string(row.Color)})
- }
- return tagRows
-}
-
-func tagAssignmentsInternal(rows []ProjectTag) []projecttypes.TagAssignment {
- assignments := make([]projecttypes.TagAssignment, 0, len(rows))
- for _, row := range rows {
- assignments = append(assignments, projecttypes.TagAssignment{ProjectID: row.ProjectID, Name: row.Name, Source: projecttypes.TagSource(row.Source), Color: projecttypes.TagColor(row.Color)})
- }
- return assignments
-}
diff --git a/backend/internal/project/service.go b/backend/internal/project/service.go
index 9bd820684..f9c8107bc 100644
--- a/backend/internal/project/service.go
+++ b/backend/internal/project/service.go
@@ -27,7 +27,6 @@ import (
"github.com/getarcaneapp/arcane/types/v2/volume"
workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
"github.com/moby/moby/api/types/container"
- dockerregistry "github.com/moby/moby/api/types/registry"
"github.com/moby/moby/client"
"github.com/samber/mo"
"go.getarcane.app/acfs"
@@ -76,6 +75,18 @@ import (
workspacepkg "github.com/getarcaneapp/arcane/backend/v2/pkg/workspace"
)
+const (
+ maxConcurrentComposeReads = 8
+ // inferredServiceCountBatchSize keeps one inferred count update under
+ // SQLite's bound variable limit (three placeholders per id).
+ inferredServiceCountBatchSize = 200
+)
+
+var (
+ composeStopProjectServices = projects.ComposeStop
+ composeUpProjectServices = projects.ComposeUp
+)
+
type ProjectService struct {
composeCoordinator projecttypes.ComposeCoordinator
db *database.DB
@@ -97,7 +108,7 @@ type ProjectService struct {
// cleanup pass must not interleave with another run's.
syncMu sync.Mutex
- composeNames composeNameCacheInternal
+ composeNames composeNameCache
parsedCompose projecttypes.ComposeCache[*types.Project]
// metaCache holds per-project icon/URL metadata, keyed by project ID. Deriving
// it costs a full compose load (interpolation plus .env reads) and, for GitOps
@@ -121,7 +132,7 @@ func (s *ProjectService) EnsureGitOpsProjectLinked(ctx context.Context, gitOpsSy
}
cacheBinding := func() {
- s.composeNames.putInternal(projects.NormalizeProjectName(project.Name), project.ID)
+ s.composeNames.put(projects.NormalizeProjectName(project.Name), project.ID)
}
if gitOpsSync.ProjectID != nil && *gitOpsSync.ProjectID == project.ID && project.GitOpsManagedBy != nil && *project.GitOpsManagedBy == gitOpsSync.ID {
cacheBinding()
@@ -170,7 +181,7 @@ func (s *ProjectService) ValidateComposeDirectory(ctx context.Context, projectNa
if err != nil {
return 0, err
}
- pathMapper := s.projectPathMapperInternal(ctx)
+ pathMapper := s.projectPathMapper(ctx)
composeProject, err := projects.LoadComposeProject(
ctx,
filepath.Join(projectPath, composeFileName),
@@ -211,8 +222,8 @@ func (s *ProjectService) CreateGitOpsManagedProject(ctx context.Context, gitOpsS
gitOpsSync.ProjectID = &project.ID
project.GitOpsManagedBy = &gitOpsSync.ID
- s.composeNames.putInternal(projects.NormalizeProjectName(project.Name), project.ID)
- if err := s.reconcileComposeTagsForProjectInternal(ctx, project); err != nil {
+ s.composeNames.put(projects.NormalizeProjectName(project.Name), project.ID)
+ if err := s.reconcileComposeTagsForProject(ctx, project); err != nil {
slog.WarnContext(ctx, "failed to reconcile Compose project tags during GitOps project creation", "projectId", project.ID, "error", err)
}
logEvent := true
@@ -228,36 +239,30 @@ func (s *ProjectService) CreateGitOpsManagedProject(ctx context.Context, gitOpsS
return nil
}
-// projectMetadataEnvInternal carries the request-scoped inputs compose
-// resolution needs beyond the project itself. Resolving them costs a settings
-// clone, a stat syscall, and a gitops_syncs query each, so list paths resolve
-// once and reuse across metadata and update enrichment for every project.
-const maxConcurrentComposeReads = 8
-
-// newProjectMetadataEnvInternal resolves the shared inputs once and preloads
+// newProjectMetadataEnv resolves the shared inputs once and preloads
// the GitOps compose paths of every listed project in a single query.
-func (s *ProjectService) newProjectMetadataEnvInternal(ctx context.Context, projectsList []Project) *projectMetadataEnvInternal {
+func (s *ProjectService) newProjectMetadataEnv(ctx context.Context, projectsList []Project) *projectMetadataEnv {
projectsDirectory, err := s.GetProjectsDirectory(ctx)
if err != nil {
slog.WarnContext(ctx, "failed to resolve projects directory for compose selection", "error", err)
}
- env := &projectMetadataEnvInternal{
+ env := &projectMetadataEnv{
projectsDirectory: projectsDirectory,
autoInjectEnv: s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false),
settings: s.settingsService.GetSettingsOrDefaults(ctx),
composeFiles: make(map[string]string, len(projectsList)),
}
- s.preloadGitOpsComposePathsInternal(ctx, env, projectsList)
+ s.preloadGitOpsComposePaths(ctx, env, projectsList)
return env
}
-// preloadGitOpsComposePathsInternal fetches the GitOps compose paths of the
+// preloadGitOpsComposePaths fetches the GitOps compose paths of the
// given projects in one query and merges them into env, so list paths can
// widen the preloaded set to the rows they end up enriching.
-func (s *ProjectService) preloadGitOpsComposePathsInternal(ctx context.Context, env *projectMetadataEnvInternal, projectsList []Project) {
+func (s *ProjectService) preloadGitOpsComposePaths(ctx context.Context, env *projectMetadataEnv, projectsList []Project) {
syncIDs := make([]string, 0, len(projectsList))
for _, proj := range projectsList {
- if id := gitOpsSyncIDInternal(&proj); id != "" {
+ if id := gitOpsSyncID(&proj); id != "" {
syncIDs = append(syncIDs, id)
}
}
@@ -288,21 +293,16 @@ func NewProjectService(
eventService *event.EventService,
imageService *image.ImageService,
dockerService *dockerInternal.DockerClientService,
- buildService buildServiceInternal,
+ buildService builder,
lifecycleService *LifecycleService,
containerRegistryService *registry.ContainerRegistryService,
cfg *config.Config,
kvService *kv.KVService,
- registryCredentialsProvider func(
- context.Context,
- ) (
- []containerregistry.Credential,
- error,
- ),
+ registryCredentialsProvider func(context.Context) ([]containerregistry.Credential, error),
) *ProjectService {
s := &ProjectService{
RegistryCredentialsProvider: registryCredentialsProvider,
- composeCoordinator: projects.NewCoordinator(projecttypes.ComposeCommands{Stop: composeStopProjectServicesInternal, Up: composeUpProjectServicesInternal, Create: projects.ComposeCreate}),
+ composeCoordinator: projects.NewCoordinator(projecttypes.ComposeCommands{Stop: composeStopProjectServices, Up: composeUpProjectServices, Create: projects.ComposeCreate}),
db: db,
settingsService: settingsService,
eventService: eventService,
@@ -315,41 +315,38 @@ func NewProjectService(
metaCache: projects.NewComposeCache[projects.ArcaneComposeMetadata](1024, nil),
FilesChanged: concurrency.NewSignal[string](),
}
- s.initChildrenInternal(kvService, buildService)
+ s.initChildren(kvService, buildService)
return s
}
-// initChildrenInternal builds the feature services from the parent's
+// initChildren builds the feature services from the parent's
// dependencies and callbacks.
-func (s *ProjectService) initChildrenInternal(kvService *kv.KVService, buildService buildServiceInternal) {
+func (s *ProjectService) initChildren(kvService *kv.KVService, buildService builder) {
s.workspace = workspace.New(s.config)
s.details = projectdetails.New(s.db, s.dockerService, s.imageService, s.settingsService)
s.listing = listing.New(
s.details.ComposeContainers,
s.imageService,
func(imageRefs []string, services []projecttypes.RuntimeService, scoped map[string]*imagetypes.UpdateInfo) *projecttypes.UpdateInfo {
- return BuildUpdateInfoSummary(imageRefs, projectdetails.MergeProjectContainerUpdateInfo(nil, services, scoped))
+ return buildUpdateInfoSummary(imageRefs, projectdetails.MergeProjectContainerUpdateInfo(nil, services, scoped))
},
)
s.deployment = deployment.New(s.settingsService, s.imageService, s.dockerService, buildService)
- s.updates = update.New(kvService, s.dockerService, s.containerRegistryService, s.ResolveRegistryCredentials, s.renameProjectStateInternal, s.restoreRenamedProjectInternal)
-}
-
-// renameProjectStateInternal reports the stored name and path rename recovery
-// compares against its journal.
-func (s *ProjectService) renameProjectStateInternal(ctx context.Context, projectID string) (string, string, bool, error) {
- proj, found, err := s.FindProjectByID(ctx, projectID)
- if err != nil || !found {
- return "", "", found, err
+ // Rename recovery compares the stored name and path against its journal and
+ // rolls the row back to its pre-rename identity.
+ renameState := func(ctx context.Context, projectID string) (string, string, bool, error) {
+ proj, found, err := s.FindProjectByID(ctx, projectID)
+ if err != nil || !found {
+ return "", "", found, err
+ }
+ return proj.Name, proj.Path, true, nil
+ }
+ restoreRenamed := func(ctx context.Context, journal *projecttypes.RenameJournal) error {
+ return s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", journal.ProjectID).Updates(map[string]any{
+ "name": journal.OldName, "path": journal.OldPath, "dir_name": journal.OldDirName,
+ }).Error
}
- return proj.Name, proj.Path, true, nil
-}
-
-// restoreRenamedProjectInternal rolls a project row back to its pre-rename identity.
-func (s *ProjectService) restoreRenamedProjectInternal(ctx context.Context, journal *projecttypes.RenameJournal) error {
- return s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", journal.ProjectID).Updates(map[string]any{
- "name": journal.OldName, "path": journal.OldPath, "dir_name": journal.OldDirName,
- }).Error
+ s.updates = update.New(kvService, s.dockerService, s.containerRegistryService, s.ResolveRegistryCredentials, renameState, restoreRenamed)
}
// RecoverProjectRenameJournals replays renames interrupted by a restart.
@@ -370,23 +367,8 @@ func (s *ProjectService) ResolveRegistryCredentials(ctx context.Context) ([]cont
return credentials, nil
}
-func (s *ProjectService) composeRegistryAuthConfigsInternal(ctx context.Context) map[string]dockerregistry.AuthConfig {
- if s == nil || s.containerRegistryService == nil {
- return nil
- }
-
- authConfigs, err := s.containerRegistryService.GetAllRegistryAuthConfigs(ctx)
- if err != nil {
- slog.WarnContext(ctx, "failed to load registry auth for compose pulls", "error", err)
- return nil
- }
-
- return authConfigs
-}
-
func (s *ProjectService) GetProjectsDirectory(ctx context.Context) (string, error) {
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDir, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ projectsDir, err := projects.GetProjectsDirectory(ctx, s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"))
if err != nil {
return "", err
}
@@ -394,7 +376,7 @@ func (s *ProjectService) GetProjectsDirectory(ctx context.Context) (string, erro
return filepath.Clean(projectsDir), nil
}
-func (s *ProjectService) getMutableProjectInternal(ctx context.Context, projectID string) (*Project, error) {
+func (s *ProjectService) getMutableProject(ctx context.Context, projectID string) (*Project, error) {
proj, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
return nil, err
@@ -405,7 +387,7 @@ func (s *ProjectService) getMutableProjectInternal(ctx context.Context, projectI
return proj, nil
}
-func (s *ProjectService) logProjectEventInternal(ctx context.Context, eventType event.EventType, projectID, projectName string, user usertypes.Actor, metadata database.JSON, action string) {
+func (s *ProjectService) logProjectEvent(ctx context.Context, eventType event.EventType, projectID, projectName string, user usertypes.Actor, metadata database.JSON, action string) {
if s.eventService == nil {
return
}
@@ -458,24 +440,34 @@ func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name strin
var proj Project
err := s.db.WithContext(ctx).Where("name = ? OR name = ?", name, normalized).First(&proj).Error
if err == nil {
- s.composeNames.putInternal(normalized, proj.ID)
+ s.composeNames.put(normalized, proj.ID)
return &proj, nil
}
if !errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf("failed to get project by name: %w", err)
}
- if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {
+ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeName(ctx, normalized); cacheErr != nil {
return nil, cacheErr
} else if found {
return cachedProject, nil
}
- if rebuildComposeNameCacheErr := s.rebuildComposeNameCacheInternal(ctx); rebuildComposeNameCacheErr != nil {
- return nil, fmt.Errorf("failed to list projects by compose name: %w", rebuildComposeNameCacheErr)
+ var projectModels []Project
+ if listErr := s.db.WithContext(ctx).Select("id", "name").Find(&projectModels).Error; listErr != nil {
+ return nil, fmt.Errorf("failed to list projects by compose name: %w", listErr)
+ }
+ byName := make(map[string]string, len(projectModels))
+ for _, projectModel := range projectModels {
+ if normalizedName := projects.NormalizeProjectName(projectModel.Name); normalizedName != "" {
+ if _, exists := byName[normalizedName]; !exists {
+ byName[normalizedName] = projectModel.ID
+ }
+ }
}
+ s.composeNames.replace(byName)
- if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {
+ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeName(ctx, normalized); cacheErr != nil {
return nil, cacheErr
} else if found {
return cachedProject, nil
@@ -488,7 +480,7 @@ func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name strin
// If not, it normalizes the path to `<projectsRoot>/<dirName or sanitized project name>`. When persist=true, it saves
// the updated project path to the database.
func (s *ProjectService) EnsureProjectPathUnderRoot(ctx context.Context, proj *Project, persist bool) error {
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"))
+ projectsDirectory, err := s.GetProjectsDirectory(ctx)
if err != nil {
return fmt.Errorf("failed to get projects directory: %w", err)
}
@@ -523,7 +515,7 @@ func (s *ProjectService) EnsureProjectPathUnderRoot(ctx context.Context, proj *P
return nil
}
-func (s *ProjectService) projectPathMapperInternal(ctx context.Context) *projects.PathMapper {
+func (s *ProjectService) projectPathMapper(ctx context.Context) *projects.PathMapper {
var dockerClient *client.Client
if s.dockerService != nil {
dockerClient, _ = s.dockerService.GetClient(ctx)
@@ -536,7 +528,7 @@ func (s *ProjectService) projectPathMapperInternal(ctx context.Context) *project
)
}
-func (s *ProjectService) invalidateProjectCachesInternal(projectID string) {
+func (s *ProjectService) invalidateProjectCaches(projectID string) {
if s.parsedCompose != nil {
s.parsedCompose.Invalidate(projectID)
}
@@ -545,8 +537,8 @@ func (s *ProjectService) invalidateProjectCachesInternal(projectID string) {
}
}
-func (s *ProjectService) lookupProjectByCachedComposeNameInternal(ctx context.Context, normalizedName string) (*Project, bool, error) {
- projectID, ok := s.composeNames.projectIDInternal(normalizedName).Get()
+func (s *ProjectService) lookupProjectByCachedComposeName(ctx context.Context, normalizedName string) (*Project, bool, error) {
+ projectID, ok := s.composeNames.projectID(normalizedName).Get()
if !ok {
return nil, false, nil
}
@@ -554,7 +546,7 @@ func (s *ProjectService) lookupProjectByCachedComposeNameInternal(ctx context.Co
var projectModel Project
if err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&projectModel).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- s.composeNames.invalidateInternal(normalizedName)
+ s.composeNames.invalidate(normalizedName)
return nil, false, nil
}
if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
@@ -563,162 +555,110 @@ func (s *ProjectService) lookupProjectByCachedComposeNameInternal(ctx context.Co
return nil, false, fmt.Errorf("failed to get project by cached compose name: %w", err)
}
if projects.NormalizeProjectName(projectModel.Name) != normalizedName {
- s.composeNames.invalidateInternal(normalizedName)
+ s.composeNames.invalidate(normalizedName)
return nil, false, nil
}
return &projectModel, true, nil
}
-func (s *ProjectService) rebuildComposeNameCacheInternal(ctx context.Context) error {
- var projectModels []Project
- if err := s.db.WithContext(ctx).Select("id", "name").Find(&projectModels).Error; err != nil {
- return err
- }
-
- byName := make(map[string]string, len(projectModels))
- for i := range projectModels {
- normalizedName := projects.NormalizeProjectName(projectModels[i].Name)
- if normalizedName == "" {
- continue
- }
- if _, exists := byName[normalizedName]; !exists {
- byName[normalizedName] = projectModels[i].ID
- }
- }
-
- s.composeNames.replaceInternal(byName)
-
- return nil
-}
-
// ResolveProjectComposeFile returns the base compose file for a project. The
// precedence mirrors `docker compose`: COMPOSE_FILE in the merged environment
// (.env.global first, the project's .env on top) wins, then a GitOps sync's
// configured compose path, then standard detection.
func (s *ProjectService) ResolveProjectComposeFile(ctx context.Context, proj *Project) (string, error) {
- return s.resolveProjectComposeFileInternal(ctx, proj, nil)
+ return s.resolveProjectComposeFile(ctx, proj, nil)
}
-// resolveProjectComposeFileInternal is ResolveProjectComposeFile with the
+// resolveProjectComposeFile is ResolveProjectComposeFile with the
// request-scoped inputs supplied by env; a nil env resolves them per call.
-func (s *ProjectService) resolveProjectComposeFileInternal(ctx context.Context, proj *Project, env *projectMetadataEnvInternal) (string, error) {
+func (s *ProjectService) resolveProjectComposeFile(ctx context.Context, proj *Project, env *projectMetadataEnv) (string, error) {
if proj == nil {
return "", errors.New("project is nil")
}
- return env.composeFileInternal(proj.ID, func() (string, error) {
- return s.resolveProjectComposeFileUncachedInternal(ctx, proj, env)
- })
-}
-
-func (s *ProjectService) resolveProjectComposeFileUncachedInternal(ctx context.Context, proj *Project, env *projectMetadataEnvInternal) (string, error) {
- projectsDirectory := ""
- switch {
- case env != nil:
- projectsDirectory = env.projectsDirectory
- case s.settingsService != nil:
- var dirErr error
- projectsDirectory, dirErr = s.GetProjectsDirectory(ctx)
- if dirErr != nil {
- // The .env.global layer is skipped for an empty projects directory;
- // keep resolution working but surface the misconfiguration.
- slog.WarnContext(ctx, "failed to resolve projects directory for compose selection", "projectId", proj.ID, "error", dirErr)
+ return env.composeFile(proj.ID, func() (string, error) {
+ projectsDirectory := ""
+ switch {
+ case env != nil:
+ projectsDirectory = env.projectsDirectory
+ case s.settingsService != nil:
+ var dirErr error
+ projectsDirectory, dirErr = s.GetProjectsDirectory(ctx)
+ if dirErr != nil {
+ // The .env.global layer is skipped for an empty projects directory;
+ // keep resolution working but surface the misconfiguration.
+ slog.WarnContext(ctx, "failed to resolve projects directory for compose selection", "projectId", proj.ID, "error", dirErr)
+ }
+ }
+ if files, selErr := projects.ComposeFileEnvSelection(ctx, projectsDirectory, proj.Path); selErr != nil {
+ return "", selErr
+ } else if len(files) > 0 {
+ return files[0], nil
}
- }
- if files, selErr := projects.ComposeFileEnvSelection(ctx, projectsDirectory, proj.Path); selErr != nil {
- return "", selErr
- } else if len(files) > 0 {
- return files[0], nil
- }
- if syncID := gitOpsSyncIDInternal(proj); syncID != "" {
- composePath, found, err := s.gitOpsComposePathInternal(ctx, syncID, env)
- if err != nil {
- return "", fmt.Errorf("failed to resolve GitOps compose path for project %s: %w", proj.ID, err)
- }
- if found {
- composeFileName := strings.TrimSpace(filepath.Base(composePath))
- if composeFileName != "" && composeFileName != "." {
- candidate := filepath.Join(proj.Path, composeFileName)
- // os.Stat rather than acfs: proj.Path may be an imported project
- // outside the projects directory, and the compose file may be a
- // symlink resolving outside it.
- if info, statErr := os.Stat(candidate); statErr == nil {
- if !info.IsDir() {
- return candidate, nil
- }
- } else if !os.IsNotExist(statErr) {
- return "", fmt.Errorf("failed to inspect GitOps compose file %s: %w", candidate, statErr)
+ // A GitOps sync's configured compose path comes from the preloaded request
+ // map when available; a sync without a row resolves like a missing one.
+ composePath := ""
+ if syncID := gitOpsSyncID(proj); syncID != "" {
+ preloaded := false
+ if env != nil {
+ composePath, preloaded = env.gitOpsComposePaths[syncID]
+ }
+ if !preloaded {
+ var syncRecord GitOpsSync
+ if err := s.db.WithContext(ctx).Select("compose_path").Where("id = ?", syncID).First(&syncRecord).Error; err == nil {
+ composePath = syncRecord.ComposePath
+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return "", fmt.Errorf("failed to resolve GitOps compose path for project %s: %w", proj.ID, err)
}
}
}
- }
-
- composeFile, err := projects.DetectComposeFile(ctx, projectsDirectory, proj.Path)
- if err != nil {
- if errors.Is(err, common.ErrProjectEnvUnreadable) {
- return "", err
+ if composeFileName := strings.TrimSpace(filepath.Base(composePath)); composeFileName != "" && composeFileName != "." {
+ candidate := filepath.Join(proj.Path, composeFileName)
+ // os.Stat rather than acfs: proj.Path may be an imported project
+ // outside the projects directory, and the compose file may be a
+ // symlink resolving outside it.
+ info, statErr := os.Stat(candidate)
+ if statErr == nil && !info.IsDir() {
+ return candidate, nil
+ }
+ if statErr != nil && !os.IsNotExist(statErr) {
+ return "", fmt.Errorf("failed to inspect GitOps compose file %s: %w", candidate, statErr)
+ }
}
- return "", common.Classify(common.ErrProjectComposeFileNotFound, fmt.Errorf("Project compose file not found: %w", err))
- }
-
- return composeFile, nil
-}
-// gitOpsComposePathInternal returns the configured compose path of a GitOps
-// sync, served from the preloaded request map when one is available.
-func (s *ProjectService) gitOpsComposePathInternal(ctx context.Context, syncID string, env *projectMetadataEnvInternal) (string, bool, error) {
- if env != nil {
- if composePath, preloaded := env.gitOpsComposePaths[syncID]; preloaded {
- return composePath, true, nil
+ composeFile, err := projects.DetectComposeFile(ctx, projectsDirectory, proj.Path)
+ if err != nil {
+ if errors.Is(err, common.ErrProjectEnvUnreadable) {
+ return "", err
+ }
+ return "", common.Classify(common.ErrProjectComposeFileNotFound, fmt.Errorf("Project compose file not found: %w", err))
}
- }
- var syncRecord GitOpsSync
- err := s.db.WithContext(ctx).Select("compose_path").Where("id = ?", syncID).First(&syncRecord).Error
- switch {
- case err == nil:
- return syncRecord.ComposePath, true, nil
- case errors.Is(err, gorm.ErrRecordNotFound):
- return "", false, nil
- default:
- return "", false, err
- }
+ return composeFile, nil
+ })
}
-// loadComposeProjectForProjectInternal loads the executable compose model for
+// loadComposeProjectForProject loads the executable compose model for
// proj. prepare is optional and runs before host path translation; deployment
// paths use it to create missing bind directories, read paths pass nil.
-func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Context, proj *Project, prepare projects.PrepareProjectFunc, services ...string) (*types.Project, string, error) {
+func (s *ProjectService) loadComposeProjectForProject(ctx context.Context, proj *Project, prepare projects.PrepareProjectFunc, services ...string) (*types.Project, string, error) {
composeFileFullPath, err := s.ResolveProjectComposeFile(ctx, proj)
if err != nil {
return nil, "", err
}
cfg := s.settingsService.GetSettingsOrDefaults(ctx)
- projectsDirectory := getProjectsDirectoryOrDefaultInternal(ctx, cfg)
+ projectsDirectory, dirErr := projects.GetProjectsDirectory(ctx, cfg.ProjectsDirectory.Value)
+ if dirErr != nil {
+ slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", dirErr)
+ projectsDirectory = "/app/data/projects"
+ }
- pathMapper := s.projectPathMapperInternal(ctx)
+ pathMapper := s.projectPathMapper(ctx)
- composeProject, loadErr := projects.LoadComposeProject(
- ctx,
- composeFileFullPath,
- projects.NormalizeProjectName(
- proj.Name,
- ),
- projectsDirectory,
- kit.ParseOrDefault(
- cfg.AutoInjectEnv.Value,
- false,
- strconv.ParseBool,
- ),
- pathMapper,
- nil,
- nil,
- false,
- nil,
- services,
- prepare,
- )
+ autoInjectEnv := kit.ParseOrDefault(cfg.AutoInjectEnv.Value, false, strconv.ParseBool)
+ projectName := projects.NormalizeProjectName(proj.Name)
+ composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, false, nil, services, prepare)
if loadErr != nil {
return nil, "", loadErr
}
@@ -726,7 +666,7 @@ func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Contex
return composeProject, composeFileFullPath, nil
}
-func (s *ProjectService) getCachedComposeProjectInternal(ctx context.Context, proj *Project, env *projectMetadataEnvInternal) (*types.Project, error) {
+func (s *ProjectService) getCachedComposeProject(ctx context.Context, proj *Project, env *projectMetadataEnv) (*types.Project, error) {
if proj == nil {
return nil, errors.New("project is nil")
}
@@ -737,45 +677,32 @@ func (s *ProjectService) getCachedComposeProjectInternal(ctx context.Context, pr
if cfg == nil {
cfg = s.settingsService.GetSettingsOrDefaults(ctx)
}
- composePath, err := s.resolveProjectComposeFileInternal(ctx, proj, env)
+ composePath, err := s.resolveProjectComposeFile(ctx, proj, env)
if err != nil {
return nil, err
}
- return projects.LoadCachedComposeProject(
- ctx,
- s.parsedCompose,
- proj.ID,
- proj.Path,
- composePath,
- projects.NormalizeProjectName(
- proj.Name,
- ),
- getProjectsDirectoryOrDefaultInternal(
- ctx,
- cfg,
- ),
- kit.ParseOrDefault(
- cfg.AutoInjectEnv.Value,
- false,
- strconv.ParseBool,
- ),
- s.projectPathMapperInternal(
- ctx,
- ),
- )
+ autoInjectEnv := kit.ParseOrDefault(cfg.AutoInjectEnv.Value, false, strconv.ParseBool)
+ projectsDirectory, dirErr := projects.GetProjectsDirectory(ctx, cfg.ProjectsDirectory.Value)
+ if dirErr != nil {
+ slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", dirErr)
+ projectsDirectory = "/app/data/projects"
+ }
+ return projects.LoadCachedComposeProject(ctx, s.parsedCompose, proj.ID, proj.Path, composePath, projects.NormalizeProjectName(proj.Name), projectsDirectory, autoInjectEnv, s.projectPathMapper(ctx))
}
-func (s *ProjectService) refreshComposeProjectNameInternal(ctx context.Context, proj *Project) {
+func (s *ProjectService) refreshComposeProjectName(ctx context.Context, proj *Project) {
if proj == nil {
return
}
- dirName := proj.Name
- if proj.DirName != nil && *proj.DirName != "" {
- dirName = *proj.DirName
+ cfg := s.settingsService.GetSettingsOrDefaults(ctx)
+ projectsDirectory, err := projects.GetProjectsDirectory(ctx, cfg.ProjectsDirectory.Value)
+ var meta projecttypes.ComposeIdentity
+ if err == nil {
+ dirName := cmp.Or(mo.PointerToOption(proj.DirName).OrEmpty(), proj.Name)
+ autoInjectEnv := kit.ParseOrDefault(cfg.AutoInjectEnv.Value, false, strconv.ParseBool)
+ meta, err = projectsync.LoadComposeMetadata(ctx, proj.Path, dirName, projectsDirectory, autoInjectEnv, s.projectPathMapper(ctx))
}
-
- meta, err := s.loadComposeMetadataForSyncInternal(ctx, proj.Path, dirName)
if err != nil {
if errors.Is(err, common.ErrProjectEnvUnreadable) {
slog.DebugContext(ctx, "skipped compose project name refresh; project env is unreadable", "projectId", proj.ID, "path", proj.Path, "error", err)
@@ -814,15 +741,8 @@ func (s *ProjectService) refreshComposeProjectNameInternal(ctx context.Context,
}
}
-// LifecycleService runs pre-deploy lifecycle hooks declared on a project's
-// GitOps sync. A hook is a script in the synced repo executed in a throwaway
-// container immediately before the project is deployed, with optional capture
-// of stdout as environment variables merged into the compose env.
-//
-// Trust model: the script is repo-trusted code, equivalent to compose.yaml in
-// the same repo. Anyone who can push to that repo can change what the script
-// does on the next deploy. The trust event is configuring a script path on
-// the GitOps sync, not each individual deploy.
+// LifecycleService runs a GitOps sync's pre-deploy script in a throwaway container.
+// The script is trusted like the repo's compose.yaml; configuring its path is the trust event.
type LifecycleService struct {
db *database.DB
settingsService *settings.SettingsService
@@ -849,45 +769,35 @@ func NewLifecycleService(
}
}
-// RunPreDeploy executes the pre-deploy lifecycle hook for a project, if one
-// is configured on its GitOps sync.
-//
-// Callers should invoke this unconditionally before deploying — when no hook
-// is configured, when lifecycle hooks are disabled globally, or when the
-// project is not GitOps-managed, this is a no-op and returns nil.
-//
-// A non-zero exit code, a script timeout, or any infrastructure failure
-// returns an error that aborts the deploy. The last-run state on the
-// GitOpsSync row is updated on every invocation that reaches the run step,
-// regardless of outcome.
-func (s *LifecycleService) RunPreDeploy(ctx context.Context, project *Project, actor usertypes.Actor) error {
- if project == nil || project.GitOpsManagedBy == nil || *project.GitOpsManagedBy == "" {
- return nil
- }
- if !s.settingsService.GetBoolSetting(ctx, "lifecycleEnabled", false) {
+// runPreDeploy runs the sync's pre-deploy hook, if configured and enabled. Any
+// failure aborts the deploy; every run records its last-run state on the sync.
+func (s *LifecycleService) runPreDeploy(ctx context.Context, project *Project, actor usertypes.Actor) error {
+ if gitOpsSyncID(project) == "" || !s.settingsService.GetBoolSetting(ctx, "lifecycleEnabled", false) {
return nil
}
- syncRecord, err := loadGitOpsSyncForProjectInternal(ctx, s.db, project.ID)
- if err != nil {
+ var syncRecord GitOpsSync
+ switch err := s.db.WithContext(ctx).Where("project_id = ?", project.ID).First(&syncRecord).Error; {
+ case errors.Is(err, gorm.ErrRecordNotFound):
+ return nil
+ case err != nil:
return fmt.Errorf("failed to load gitops sync for lifecycle hook: %w", err)
}
- if syncRecord == nil || syncRecord.PreDeployScriptPath == nil || strings.TrimSpace(*syncRecord.PreDeployScriptPath) == "" {
+ if syncRecord.PreDeployScriptPath == nil || strings.TrimSpace(*syncRecord.PreDeployScriptPath) == "" {
return nil
}
- return s.executePreDeployInternal(ctx, project, syncRecord, actor)
-}
-
-func (s *LifecycleService) executePreDeployInternal(ctx context.Context, project *Project, syncRecord *GitOpsSync, actor usertypes.Actor) error {
- runnerImage := s.hooks.RunnerImage(ctx, syncRecord.PreDeployRunnerImage)
+ runnerImage := cmp.Or(
+ strings.TrimSpace(mo.PointerToOption(syncRecord.PreDeployRunnerImage).OrEmpty()),
+ strings.TrimSpace(s.settingsService.GetStringSetting(ctx, "lifecycleDefaultRunnerImage", "alpine:latest")),
+ )
if runnerImage == "" {
return fmt.Errorf("pre-deploy script %q is configured but no runner image is set on the GitOps sync or lifecycleDefaultRunnerImage setting", *syncRecord.PreDeployScriptPath)
}
scriptPath := strings.TrimSpace(*syncRecord.PreDeployScriptPath)
- if err := lifecycle.ValidateScriptPath(ctx, project.Path, scriptPath); err != nil {
- return fmt.Errorf("invalid pre-deploy script path: %w", err)
+ if validateErr := lifecycle.ValidateScriptPath(ctx, project.Path, scriptPath); validateErr != nil {
+ return fmt.Errorf("invalid pre-deploy script path: %w", validateErr)
}
hookEnv, err := ParseEnvText(syncRecord.PreDeployEnv)
@@ -899,8 +809,11 @@ func (s *LifecycleService) executePreDeployInternal(ctx context.Context, project
return fmt.Errorf("invalid lifecycle extra mounts config: %w", err)
}
- timeout := s.hooks.Timeout(ctx, syncRecord.PreDeployTimeoutSec)
-
+ timeoutSec := kit.Ternary(syncRecord.PreDeployTimeoutSec > 0, syncRecord.PreDeployTimeoutSec, lifecycletype.DefaultTimeoutSec)
+ if maxTimeoutSec := s.settingsService.GetIntSetting(ctx, "lifecycleMaxTimeoutSec", lifecycletype.DefaultMaxTimeoutSec); maxTimeoutSec > 0 {
+ timeoutSec = min(timeoutSec, maxTimeoutSec)
+ }
+ timeout := time.Duration(timeoutSec) * time.Second
slog.InfoContext(ctx, "running pre-deploy lifecycle hook",
"projectId", project.ID,
"syncId", syncRecord.ID,
@@ -910,66 +823,30 @@ func (s *LifecycleService) executePreDeployInternal(ctx context.Context, project
)
start := time.Now()
- stdoutContent, stderrContent, exitCode, runErr := s.hooks.RunScript(
- ctx,
- runnerImage,
- project.Path,
- scriptPath,
- hookEnv,
- extraMounts,
- syncRecord.PreDeployNetworkMode,
- timeout,
- actor,
- )
+ stdoutContent, stderrContent, exitCode, runErr := s.hooks.RunScript(ctx, runnerImage, project.Path, scriptPath, hookEnv, extraMounts, syncRecord.PreDeployNetworkMode, timeout, actor)
durationMs := time.Since(start).Milliseconds()
-
- status := lifecycle.LifecycleStatusForResult(exitCode, runErr)
- // stdoutBuf/stderrBuf already enforce lifecycleMaxOutputBytes each with a
- // proper "...<truncated>" marker, so the combined string is already
- // bounded and we don't slice again here — a second byte-boundary cut
- // could land mid-UTF-8 codepoint and produce garbled output.
- persistedOutput := lifecycle.CombineLifecycleOutput(stdoutContent, stderrContent)
- s.persistLastRunInternal(ctx, syncRecord.ID, status, persistedOutput, start)
- s.emitLifecycleEventInternal(ctx, project, syncRecord, runnerImage, status, exitCode, durationMs, runErr, actor)
-
- if runErr != nil {
- return runErr
- }
- if exitCode != 0 {
- return fmt.Errorf("pre-deploy script exited with status %d", exitCode)
+ status := lifecycle.LifecycleStatusSuccess
+ switch {
+ case errors.Is(runErr, context.DeadlineExceeded):
+ status = lifecycle.LifecycleStatusTimeout
+ case runErr != nil || exitCode != 0:
+ status = lifecycle.LifecycleStatusFailed
}
- return nil
-}
-func (s *LifecycleService) persistLastRunInternal(ctx context.Context, syncID, status, output string, runAt time.Time) {
- persistCtx := context.WithoutCancel(ctx)
- err := s.db.WithContext(persistCtx).
- Model(&GitOpsSync{}).
- Where("id = ?", syncID).
- Updates(map[string]any{
- "pre_deploy_last_run_at": runAt,
- "pre_deploy_last_run_status": status,
- "pre_deploy_last_run_output": output,
- }).Error
- if err != nil {
- slog.WarnContext(ctx, "failed to persist lifecycle last-run state", "syncId", syncID, "error", err)
+ // Each stream is already bounded with a truncation marker; cutting the
+ // combined output again could split a UTF-8 codepoint.
+ if persistErr := s.db.WithContext(context.WithoutCancel(ctx)).Model(&GitOpsSync{}).Where("id = ?", syncRecord.ID).Updates(map[string]any{
+ "pre_deploy_last_run_at": start,
+ "pre_deploy_last_run_status": status,
+ "pre_deploy_last_run_output": lifecycle.CombineLifecycleOutput(stdoutContent, stderrContent),
+ }).Error; persistErr != nil {
+ slog.WarnContext(ctx, "failed to persist lifecycle last-run state", "syncId", syncRecord.ID, "error", persistErr)
}
-}
-func (s *LifecycleService) emitLifecycleEventInternal(
- ctx context.Context,
- project *Project,
- syncRecord *GitOpsSync,
- runnerImage string,
- status string,
- exitCode int64,
- durationMs int64,
- runErr error,
- actor usertypes.Actor,
-) {
+ scriptPathValue := mo.PointerToOption(syncRecord.PreDeployScriptPath).OrEmpty()
severity := event.EventSeveritySuccess
title := "Pre-deploy lifecycle hook succeeded: " + project.Name
- description := fmt.Sprintf("Script %s exited with code %d in %dms", mo.PointerToOption(syncRecord.PreDeployScriptPath).OrEmpty(), exitCode, durationMs)
+ description := fmt.Sprintf("Script %s exited with code %d in %dms", scriptPathValue, exitCode, durationMs)
if status != lifecycle.LifecycleStatusSuccess {
severity = event.EventSeverityWarning
title = fmt.Sprintf("Pre-deploy lifecycle hook %s: %s", status, project.Name)
@@ -977,17 +854,7 @@ func (s *LifecycleService) emitLifecycleEventInternal(
description = runErr.Error()
}
}
-
- metadata := database.JSON{
- "scriptPath": mo.PointerToOption(syncRecord.PreDeployScriptPath).OrEmpty(),
- "runnerImage": runnerImage,
- "exitCode": exitCode,
- "durationMs": durationMs,
- "gitopsSyncId": syncRecord.ID,
- "status": status,
- }
-
- _, err := s.eventService.CreateEvent(ctx, event.CreateEventRequest{
+ if _, eventErr := s.eventService.CreateEvent(ctx, event.CreateEventRequest{
Type: event.EventTypeLifecycleExecute,
Severity: severity,
Title: title,
@@ -998,11 +865,25 @@ func (s *LifecycleService) emitLifecycleEventInternal(
EnvironmentID: new(syncRecord.EnvironmentID),
UserID: new(actor.ID),
Username: new(actor.Username),
- Metadata: metadata,
- })
- if err != nil {
- slog.WarnContext(ctx, "failed to emit lifecycle.execute event", "syncId", syncRecord.ID, "error", err)
+ Metadata: database.JSON{
+ "scriptPath": scriptPathValue,
+ "runnerImage": runnerImage,
+ "exitCode": exitCode,
+ "durationMs": durationMs,
+ "gitopsSyncId": syncRecord.ID,
+ "status": status,
+ },
+ }); eventErr != nil {
+ slog.WarnContext(ctx, "failed to emit lifecycle.execute event", "syncId", syncRecord.ID, "error", eventErr)
+ }
+
+ if runErr != nil {
+ return runErr
}
+ if exitCode != 0 {
+ return fmt.Errorf("pre-deploy script exited with status %d", exitCode)
+ }
+ return nil
}
// ParseEnvText reads admin-configured env config as the
@@ -1076,51 +957,44 @@ func ParseExtraMountsText(raw *string) ([]lifecycletype.ExtraMount, error) {
return mounts, nil
}
-var (
- composeStopProjectServicesInternal = projects.ComposeStop
- composeUpProjectServicesInternal = projects.ComposeUp
-)
-
func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user usertypes.Actor, discoverTags bool) error {
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
if discoverTags {
- effective, _, loadComposeProjectForProjectErr := s.loadComposeProjectForProjectInternal(ctx, proj, nil, servicesToUpdate...)
- if loadComposeProjectForProjectErr != nil {
- return fmt.Errorf("load project for service image checks: %w", loadComposeProjectForProjectErr)
+ effective, _, loadErr := s.loadComposeProjectForProject(ctx, proj, nil, servicesToUpdate...)
+ if loadErr != nil {
+ return fmt.Errorf("load project for service image checks: %w", loadErr)
}
- changes, loadComposeProjectForProjectErr := s.updates.ImageChanges(ctx, effective, gitOpsSyncIDInternal(proj) != "")
- if loadComposeProjectForProjectErr != nil {
- return loadComposeProjectForProjectErr
+ changes, changesErr := s.updates.ImageChanges(ctx, effective, gitOpsSyncID(proj) != "")
+ if changesErr != nil {
+ return changesErr
}
+ // ImageChanges already rejects GitOps-managed projects; tag edits need the full project.
if len(changes) > 0 {
- if _, persistProjectImageChangesErr := s.persistProjectImageChangesInternal(ctx, projectID, changes); persistProjectImageChangesErr != nil {
- return persistProjectImageChangesErr
+ full, _, fullErr := s.loadComposeProjectForProject(ctx, proj, nil)
+ if fullErr != nil {
+ return fmt.Errorf("load project for tag update: %w", fullErr)
+ }
+ if _, applyErr := s.updates.ApplyImageChanges(ctx, proj.Path, full, changes); applyErr != nil {
+ return applyErr
}
+ s.invalidateProjectCaches(projectID)
}
}
- return s.updateProjectServicesInternal(ctx, projectID, servicesToUpdate, user)
-}
-
-func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, projectID string, servicesToUpdate []string, user usertypes.Actor) error {
- projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
- if err != nil {
- return err
- }
- previousStatus := projectFromDb.Status
+ previousStatus := proj.Status
// 1. Load project
- prepare := deployment.PrepareProjectBindDirectories(projectFromDb.Path)
- compProj, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, prepare, servicesToUpdate...)
+ prepare := deployment.PrepareProjectBindDirectories(proj.Path)
+ compProj, _, err := s.loadComposeProjectForProject(ctx, proj, prepare, servicesToUpdate...)
if err != nil {
return fmt.Errorf("failed to load compose project: %w", err)
}
dependents, stoppedDependents := s.deployment.NamespaceDependents(ctx, compProj, servicesToUpdate)
if len(dependents)+len(stoppedDependents) > 0 {
slog.InfoContext(ctx, "recreating namespace dependents with updated services", "projectId", projectID, "services", servicesToUpdate, "dependents", dependents, "stoppedDependents", stoppedDependents)
- if compProj, _, err = s.loadComposeProjectForProjectInternal(ctx, projectFromDb, prepare, slices.Concat(servicesToUpdate, dependents, stoppedDependents)...); err != nil {
+ if compProj, _, err = s.loadComposeProjectForProject(ctx, proj, prepare, slices.Concat(servicesToUpdate, dependents, stoppedDependents)...); err != nil {
return fmt.Errorf("failed to load compose project with dependents: %w", err)
}
}
@@ -1128,42 +1002,66 @@ func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, proj
defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
// 2. Set status to deploying/restarting
- if updateProjectStatusErr := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusDeploying); updateProjectStatusErr != nil {
+ if updateProjectStatusErr := s.updateProjectStatus(ctx, projectID, ProjectStatusDeploying); updateProjectStatusErr != nil {
return updateProjectStatusErr
}
credentials, err := s.ResolveRegistryCredentials(ctx)
if err != nil {
- if statusErr := s.updateProjectStatusInternal(ctx, projectID, previousStatus); statusErr != nil {
+ if statusErr := s.updateProjectStatus(ctx, projectID, previousStatus); statusErr != nil {
slog.ErrorContext(ctx, "UpdateProjectServices: failed to restore project status after credential lookup failure", "projectId", projectID, "error", statusErr)
}
return fmt.Errorf("resolve registry credentials: %w", err)
}
+ authConfigs, authErr := s.containerRegistryService.GetAllRegistryAuthConfigs(ctx)
+ if authErr != nil {
+ slog.WarnContext(ctx, "failed to load registry auth for compose pulls", "error", authErr)
+ }
progressWriter, _ := ctx.Value(dockertypes.ProgressWriterKey{}).(io.Writer)
if updateServicesErr := s.composeCoordinator.UpdateServices(ctx, projecttypes.ComposeServiceUpdate{
Project: compProj, Services: servicesToUpdate, Dependents: dependents, StoppedDependents: stoppedDependents,
Images: s.deployment.ImageOperations(&user, credentials), Progress: progressWriter,
- AuthConfigs: s.composeRegistryAuthConfigsInternal(ctx), WaitTimeout: timeouts.GetDuration(s.settingsService.GetSettingsConfig().DeployWaitTimeout.AsInt(), timeouts.DefaultDeployWait),
+ AuthConfigs: authConfigs, WaitTimeout: timeouts.GetDuration(s.settingsService.GetSettingsConfig().DeployWaitTimeout.AsInt(), timeouts.DefaultDeployWait),
RestoreBeforeMutation: func(ctx context.Context) {
- if statusErr := s.updateProjectStatusInternal(ctx, projectID, previousStatus); statusErr != nil {
+ if statusErr := s.updateProjectStatus(ctx, projectID, previousStatus); statusErr != nil {
slog.ErrorContext(ctx, "failed to restore project status before service update", "projectId", projectID, "error", statusErr)
}
},
- Recover: func(ctx context.Context) { s.restoreProjectStatusAfterFailedDeployInternal(ctx, projectID) },
+ Recover: func(ctx context.Context) {
+ services, servicesErr := s.projectServices(ctx, projectID)
+ if servicesErr != nil {
+ slog.WarnContext(ctx, "failed to inspect project services after deploy failure", "projectId", projectID, "error", servicesErr)
+ } else {
+ serviceCount, runningCount := listing.ServiceCounts(services)
+ updateErr := s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", projectID).Updates(map[string]any{
+ "status": ProjectStatus(listing.ProjectStatus(services)),
+ "service_count": serviceCount,
+ "running_count": runningCount,
+ "updated_at": time.Now(),
+ }).Error
+ if updateErr == nil {
+ return
+ }
+ slog.WarnContext(ctx, "failed to restore project status after deploy failure", "projectId", projectID, "error", updateErr)
+ }
+ if updateErr := s.updateProjectStatus(ctx, projectID, ProjectStatusStopped); updateErr != nil {
+ slog.WarnContext(ctx, "failed to set stopped status after deploy failure", "projectId", projectID, "error", updateErr)
+ }
+ },
}); updateServicesErr != nil {
return updateServicesErr
}
// 6. Finalize status
- if updateProjectStatusandCountsErr := s.updateProjectStatusandCountsInternal(ctx, projectID, ProjectStatusRunning); updateProjectStatusandCountsErr != nil {
+ if updateProjectStatusandCountsErr := s.updateProjectStatusAndCounts(ctx, projectID, ProjectStatusRunning); updateProjectStatusandCountsErr != nil {
return updateProjectStatusandCountsErr
}
metadata := database.JSON{
"action": "update_services",
"projectID": projectID,
- "projectName": projectFromDb.Name,
+ "projectName": proj.Name,
"services": append([]string(nil), servicesToUpdate...),
}
if len(dependents) > 0 {
@@ -1172,7 +1070,7 @@ func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, proj
if len(stoppedDependents) > 0 {
metadata["stoppedDependents"] = stoppedDependents
}
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, projectID, projectFromDb.Name, user, metadata, "could not log project service update action")
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, projectID, proj.Name, user, metadata, "could not log project service update action")
return nil
}
@@ -1190,7 +1088,7 @@ func (s *ProjectService) ArchiveProject(ctx context.Context, projectID string, u
// stale when containers are stopped outside an Arcane project action.
// A project without a compose file cannot have managed containers running
// and is a prime archive candidate, so it is allowed through.
- services, servicesErr := s.projectServicesInternal(ctx, projectID)
+ services, servicesErr := s.projectServices(ctx, projectID)
switch {
case servicesErr != nil && !errors.Is(servicesErr, common.ErrProjectComposeFileNotFound):
return fmt.Errorf("cannot verify project is stopped before archiving: %w", servicesErr)
@@ -1209,7 +1107,7 @@ func (s *ProjectService) ArchiveProject(ctx context.Context, projectID string, u
}
metadata := database.JSON{"action": "archived", "projectID": projectID, "projectName": proj.Name}
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, projectID, proj.Name, user, metadata, "could not log project archive action")
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, projectID, proj.Name, user, metadata, "could not log project archive action")
return nil
}
@@ -1231,24 +1129,24 @@ func (s *ProjectService) UnarchiveProject(ctx context.Context, projectID string,
}
metadata := database.JSON{"action": "unarchived", "projectID": projectID, "projectName": proj.Name}
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, projectID, proj.Name, user, metadata, "could not log project unarchive action")
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, projectID, proj.Name, user, metadata, "could not log project unarchive action")
return nil
}
func (s *ProjectService) DeployProject(ctx context.Context, projectID string, user usertypes.Actor, options *projecttypes.DeployOptions) error {
- projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
- if err != nil {
+ projectFromDb, err := s.getMutableProject(ctx, projectID)
+ switch {
+ case errors.Is(err, common.ErrProjectArchived):
+ return err
+ case err != nil:
return fmt.Errorf("failed to get project: %w", err)
}
- if projectFromDb != nil && projectFromDb.IsArchived {
- return common.Classify(common.ErrProjectArchived, errors.New("project is archived and must be unarchived before this action"))
- }
if _, resolveProjectComposeFileErr := s.ResolveProjectComposeFile(ctx, projectFromDb); resolveProjectComposeFileErr != nil {
return resolveProjectComposeFileErr
}
- if updateProjectStatusErr := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusDeploying); updateProjectStatusErr != nil {
+ if updateProjectStatusErr := s.updateProjectStatus(ctx, projectID, ProjectStatusDeploying); updateProjectStatusErr != nil {
return fmt.Errorf("failed to update project status to deploying: %w", updateProjectStatusErr)
}
var closeSuppression func()
@@ -1258,25 +1156,26 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
}
}()
+ authConfigs, authErr := s.containerRegistryService.GetAllRegistryAuthConfigs(ctx)
+ if authErr != nil {
+ slog.WarnContext(ctx, "failed to load registry auth for compose pulls", "error", authErr)
+ }
progressWriter, _ := ctx.Value(dockertypes.ProgressWriterKey{}).(io.Writer)
projectModel, err := s.composeCoordinator.Deploy(ctx, projecttypes.ComposeDeployment{
ProjectID: projectID, ProjectPath: projectFromDb.Path, Options: options,
DefaultPullPolicy: s.settingsService.GetStringSetting(ctx, "defaultDeployPullPolicy", "missing"),
- GitOpsManaged: projectFromDb.GitOpsManagedBy != nil && *projectFromDb.GitOpsManagedBy != "",
- WaitTimeout: timeouts.GetDuration(
- s.settingsService.GetSettingsConfig().DeployWaitTimeout.AsInt(),
- timeouts.DefaultDeployWait,
- ), AuthConfigs: s.composeRegistryAuthConfigsInternal(
- ctx,
- ), Progress: progressWriter,
+ GitOpsManaged: gitOpsSyncID(projectFromDb) != "",
+ WaitTimeout: timeouts.GetDuration(s.settingsService.GetSettingsConfig().DeployWaitTimeout.AsInt(), timeouts.DefaultDeployWait),
+ AuthConfigs: authConfigs,
+ Progress: progressWriter,
PreDeploy: func(ctx context.Context) error {
if s.lifecycleService == nil {
return nil
}
- return s.lifecycleService.RunPreDeploy(ctx, projectFromDb, user)
+ return s.lifecycleService.runPreDeploy(ctx, projectFromDb, user)
},
Load: func(ctx context.Context) (*types.Project, error) {
- model, _, loadComposeProjectForProjectErr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, deployment.PrepareProjectBindDirectories(projectFromDb.Path))
+ model, _, loadComposeProjectForProjectErr := s.loadComposeProjectForProject(ctx, projectFromDb, deployment.PrepareProjectBindDirectories(projectFromDb.Path))
if loadComposeProjectForProjectErr == nil {
closeSuppression = s.eventService.BeginComposeSuppressionWindow(model.Name)
}
@@ -1289,16 +1188,36 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
operations.Pull = s.deployment.ImageOperations(nil, credentials).Pull
return operations, resolveRegistryCredentialsErr
},
- Recover: func(ctx context.Context) { s.restoreProjectStatusAfterFailedDeployInternal(ctx, projectID) },
+ Recover: func(ctx context.Context) {
+ services, servicesErr := s.projectServices(ctx, projectID)
+ if servicesErr != nil {
+ slog.WarnContext(ctx, "failed to inspect project services after deploy failure", "projectId", projectID, "error", servicesErr)
+ } else {
+ serviceCount, runningCount := listing.ServiceCounts(services)
+ updateErr := s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", projectID).Updates(map[string]any{
+ "status": ProjectStatus(listing.ProjectStatus(services)),
+ "service_count": serviceCount,
+ "running_count": runningCount,
+ "updated_at": time.Now(),
+ }).Error
+ if updateErr == nil {
+ return
+ }
+ slog.WarnContext(ctx, "failed to restore project status after deploy failure", "projectId", projectID, "error", updateErr)
+ }
+ if updateErr := s.updateProjectStatus(ctx, projectID, ProjectStatusStopped); updateErr != nil {
+ slog.WarnContext(ctx, "failed to set stopped status after deploy failure", "projectId", projectID, "error", updateErr)
+ }
+ },
})
if err != nil {
return err
}
metadata := database.JSON{"action": "deploy", "projectID": projectID, "projectName": projectModel.Name}
- s.logProjectEventInternal(ctx, event.EventTypeProjectDeploy, projectID, projectModel.Name, user, metadata, "could not log project deployment action")
+ s.logProjectEvent(ctx, event.EventTypeProjectDeploy, projectID, projectModel.Name, user, metadata, "could not log project deployment action")
- err = s.updateProjectStatusandCountsInternal(ctx, projectID, ProjectStatusRunning)
+ err = s.updateProjectStatusAndCounts(ctx, projectID, ProjectStatusRunning)
if err != nil {
slog.ErrorContext(ctx, "failed to update project status and counts after deploy", "projectId", projectID, "error", err)
}
@@ -1306,25 +1225,25 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
}
func (s *ProjectService) DownProject(ctx context.Context, projectID string, user usertypes.Actor) error {
- projectFromDb, err := s.getMutableProjectInternal(ctx, projectID)
+ projectFromDb, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
- proj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
+ proj, _, lerr := s.loadComposeProjectForProject(ctx, projectFromDb, nil)
if lerr != nil {
- _ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
+ _ = s.updateProjectStatus(ctx, projectID, ProjectStatusRunning)
return fmt.Errorf("failed to load compose project: %w", lerr)
}
- if updateProjectStatusErr := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusStopped); updateProjectStatusErr != nil {
+ if updateProjectStatusErr := s.updateProjectStatus(ctx, projectID, ProjectStatusStopped); updateProjectStatusErr != nil {
return fmt.Errorf("failed to update project status to stopping: %w", updateProjectStatusErr)
}
defer s.eventService.BeginComposeSuppressionWindow(proj.Name)()
if composeDownErr := projects.ComposeDown(ctx, proj, false); composeDownErr != nil {
- _ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
+ _ = s.updateProjectStatus(ctx, projectID, ProjectStatusRunning)
return fmt.Errorf("failed to bring down project: %w", composeDownErr)
}
@@ -1333,19 +1252,14 @@ func (s *ProjectService) DownProject(ctx context.Context, projectID string, user
"projectID": projectID,
"projectName": projectFromDb.Name,
}
- s.logProjectEventInternal(ctx, event.EventTypeProjectStop, projectID, projectFromDb.Name, user, metadata, "could not log project down action")
+ s.logProjectEvent(ctx, event.EventTypeProjectStop, projectID, projectFromDb.Name, user, metadata, "could not log project down action")
- return s.updateProjectStatusandCountsInternal(ctx, projectID, ProjectStatusStopped)
+ return s.updateProjectStatusAndCounts(ctx, projectID, ProjectStatusStopped)
}
-// CreateProject creates a project's directory, files, and DB row. When
-// allowNameSuffix is true a directory-name collision is resolved by appending
-// "-N" (the interactive default). When false a collision returns
-// projects.ErrProjectDirExists (wrapped) so GitOps creates fail loudly instead of
-// minting runaway "-N" duplicate projects on a broken binding.
-func (
- s *ProjectService,
-) CreateProject(
+// CreateProject creates a project's directory, files, and DB row. A directory
+// collision appends "-N" unless allowNameSuffix is false, which returns projects.ErrProjectDirExists.
+func (s *ProjectService) CreateProject(
ctx context.Context,
name, composeContent string,
envContent *string,
@@ -1355,10 +1269,7 @@ func (
uiTagColors map[string]projecttypes.TagColor,
user usertypes.Actor,
allowNameSuffixOptions ...bool,
-) (
- *Project,
- error,
-) {
+) (*Project, error) {
normalizedUITags, err := projects.NormalizeProjectTags(uiTags)
if err != nil {
return nil, fmt.Errorf("invalid project tags: %w", err)
@@ -1378,7 +1289,7 @@ func (
}
sanitized := projects.SanitizeProjectName(name)
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"))
+ projectsDirectory, err := s.GetProjectsDirectory(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get projects directory: %w", err)
}
@@ -1451,23 +1362,26 @@ func (
slog.WarnContext(ctx, "failed to read Compose project tags during creation", "projectName", name, "error", err)
composeMeta = projects.ArcaneComposeMetadata{}
}
- normalizedUITags = tags.ExcludeComposeOwnedUITags(normalizedUITags, composeMeta.ProjectTags)
+ // Compose owns the tags it declares, so they are not attached as UI tags.
+ normalizedUITags = slices.DeleteFunc(normalizedUITags, func(tag string) bool {
+ return slices.ContainsFunc(composeMeta.ProjectTags, func(composeTag projecttypes.TagOption) bool { return composeTag.Name == tag })
+ })
if transactionErr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if createProjectErr := tx.Create(proj).Error; createProjectErr != nil {
return createProjectErr
}
- return tags.AttachInitial(tagStoreInternal{tx: tx}, proj.ID, normalizedUITags, normalizedTagColors)
+ return tags.AttachInitial(tagStore{tx: tx}, proj.ID, normalizedUITags, normalizedTagColors)
}); transactionErr != nil {
_ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, projectLogical)
return nil, fmt.Errorf("failed to create project: %w", transactionErr)
}
- s.refreshComposeProjectNameInternal(ctx, proj)
- s.refreshProjectImageRefsInternal(ctx, proj)
- if reconcileComposeProjectTagsErr := s.reconcileComposeProjectTagsInternal(ctx, proj.ID, composeMeta.ProjectTags); reconcileComposeProjectTagsErr != nil {
+ s.refreshComposeProjectName(ctx, proj)
+ s.refreshProjectImageRefs(ctx, proj)
+ if reconcileComposeProjectTagsErr := s.reconcileComposeProjectTags(ctx, proj.ID, composeMeta.ProjectTags); reconcileComposeProjectTagsErr != nil {
cleanupCtx := context.WithoutCancel(ctx)
databaseCleanupErr := s.db.WithContext(cleanupCtx).Transaction(func(tx *gorm.DB) error {
- return deleteProjectWithTagsInternal(tx, proj.ID)
+ return deleteProjectWithTags(tx, proj.ID)
})
fileCleanupErr := acfs.RemoveAll(cleanupCtx, projectsDirectory, projectLogical)
if databaseCleanupErr != nil {
@@ -1480,7 +1394,7 @@ func (
}
metadata := database.JSON{"action": "create", "projectID": proj.ID, "projectName": proj.Name, "path": projectPath}
- s.logProjectEventInternal(ctx, event.EventTypeProjectCreate, proj.ID, proj.Name, user, metadata, "could not log project creation")
+ s.logProjectEvent(ctx, event.EventTypeProjectCreate, proj.ID, proj.Name, user, metadata, "could not log project creation")
return proj, nil
}
@@ -1507,7 +1421,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r
}
if removeVolumes {
- if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil); lerr == nil {
+ if compProj, _, lerr := s.loadComposeProjectForProject(ctx, proj, nil); lerr == nil {
defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
if derr := projects.ComposeDown(ctx, compProj, true); derr != nil {
slog.WarnContext(ctx, "failed to remove volumes", "error", derr)
@@ -1529,7 +1443,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r
}
if transactionErr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- return deleteProjectWithTagsInternal(tx, projectID)
+ return deleteProjectWithTags(tx, projectID)
}); transactionErr != nil {
return fmt.Errorf("failed to delete project from database: %w", transactionErr)
}
@@ -1547,16 +1461,16 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r
}
}
}
- s.invalidateProjectCachesInternal(projectID)
+ s.invalidateProjectCaches(projectID)
metadata := database.JSON{"action": "destroy", "projectID": projectID, "projectName": proj.Name, "removeFiles": removeFiles, "removeVolumes": removeVolumes}
- s.logProjectEventInternal(ctx, event.EventTypeProjectDelete, projectID, proj.Name, user, metadata, "could not log project destroy action")
+ s.logProjectEvent(ctx, event.EventTypeProjectDelete, projectID, proj.Name, user, metadata, "could not log project destroy action")
return nil
}
func (s *ProjectService) RedeployProject(ctx context.Context, projectID string, user usertypes.Actor, options *projecttypes.DeployOptions) error {
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
@@ -1565,9 +1479,18 @@ func (s *ProjectService) RedeployProject(ctx context.Context, projectID string,
return resolveProjectComposeFileErr
}
- disabled := s.projectRedeployDisabledInternal(ctx, *proj)
- if disabled {
- return errors.New("arcane cannot redeploy itself; use the system upgrade flow (Settings -> Updates) instead")
+ // Arcane's own server container must go through the system upgrade flow. A
+ // failed container listing skips the guard rather than blocking the redeploy.
+ if containers, listErr := s.details.ComposeContainers(ctx); listErr != nil {
+ slog.WarnContext(ctx, "could not list compose containers to check self-redeploy guard; skipping guard", "error", listErr)
+ } else {
+ currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
+ projectContainers := listing.ProjectContainers(projectRecord(*proj), listing.GroupComposeContainersByProject(containers))
+ if slices.ContainsFunc(projectContainers, func(c container.Summary) bool {
+ return labels.ShouldDisableArcaneServerRedeploy(c.Labels, c.ID, currentContainerID, currentContainerErr)
+ }) {
+ return errors.New("arcane cannot redeploy itself; use the system upgrade flow (Settings -> Updates) instead")
+ }
}
progressWriter, _ := ctx.Value(dockertypes.ProgressWriterKey{}).(io.Writer)
@@ -1586,48 +1509,34 @@ func (s *ProjectService) RedeployProject(ctx context.Context, projectID string,
return s.DeployProject(ctx, projectID, user, options)
}
-func (s *ProjectService) projectRedeployDisabledInternal(ctx context.Context, proj Project) bool {
- containers, err := s.details.ComposeContainers(ctx)
- if err != nil {
- slog.WarnContext(ctx, "could not list compose containers to check self-redeploy guard; skipping guard", "error", err)
- return false
- }
-
- containersByProject := listing.GroupComposeContainersByProject(containers)
-
- currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
- for _, containerSummary := range listing.ProjectContainers(projectRecordInternal(proj), containersByProject) {
- if labels.ShouldDisableArcaneServerRedeploy(containerSummary.Labels, containerSummary.ID, currentContainerID, currentContainerErr) {
- return true
- }
- }
-
- return false
-}
-
func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string, progressWriter io.Writer, user usertypes.Actor, credentials []containerregistry.Credential) error {
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
+ compProj, _, lerr := s.loadComposeProjectForProject(ctx, proj, nil)
if lerr != nil {
return fmt.Errorf("failed to load compose project: %w", lerr)
}
defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
- return s.deployment.PullImages(ctx, compProj, progressWriter, user, credentials)
+ for _, imageRef := range projects.PullableImageRefs(compProj) {
+ if pullErr := s.deployment.Pull(ctx, imageRef, progressWriter, user, credentials); pullErr != nil {
+ return pullErr
+ }
+ }
+ return nil
}
func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID string, options projecttypes.BuildOptions, progressWriter io.Writer, user *usertypes.Actor) error {
- projectFromDb, err := s.getMutableProjectInternal(ctx, projectID)
+ projectFromDb, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
- projectModel, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
+ projectModel, _, derr := s.loadComposeProjectForProject(ctx, projectFromDb, nil)
if derr != nil {
return fmt.Errorf("failed to load compose project in %s: %w", projectFromDb.Path, derr)
}
@@ -1637,53 +1546,8 @@ func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID str
return s.composeCoordinator.BuildServices(ctx, projectID, projectModel, options, progressWriter, s.deployment.ImageOperations(user, nil))
}
-// EnsureProjectImagesPresent checks all compose service images for the project and
-// pulls based on service pull policy:
-// - always/refresh: always pull
-// - missing/if_not_present/default: pull only if local image is missing
-// - never: never pull (fails early if image is missing locally)
-func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, projectID string, progressWriter io.Writer, user usertypes.Actor, credentials []containerregistry.Credential) error {
- proj, err := s.getMutableProjectInternal(ctx, projectID)
- if err != nil {
- return err
- }
-
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
- if lerr != nil {
- return fmt.Errorf("failed to load compose project: %w", lerr)
- }
-
- defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
-
- return s.composeCoordinator.EnsureImagesPresent(ctx, compProj, progressWriter, s.deployment.ImageOperations(&user, credentials))
-}
-
-func (s *ProjectService) restoreProjectStatusAfterFailedDeployInternal(ctx context.Context, projectID string) {
- services, err := s.projectServicesInternal(ctx, projectID)
- if err == nil {
- serviceCount, runningCount := listing.ServiceCounts(services)
- status := ProjectStatus(listing.ProjectStatus(services))
- updateErr := s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", projectID).Updates(map[string]any{
- "status": status,
- "service_count": serviceCount,
- "running_count": runningCount,
- "updated_at": time.Now(),
- }).Error
- if updateErr == nil {
- return
- }
- slog.WarnContext(ctx, "failed to restore project status after deploy failure", "projectId", projectID, "error", updateErr)
- } else {
- slog.WarnContext(ctx, "failed to inspect project services after deploy failure", "projectId", projectID, "error", err)
- }
-
- if updateErr := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusStopped); updateErr != nil {
- slog.WarnContext(ctx, "failed to set stopped status after deploy failure", "projectId", projectID, "error", updateErr)
- }
-}
-
func (s *ProjectService) RestartProject(ctx context.Context, projectID string, services []string, user usertypes.Actor) error {
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
return err
}
@@ -1691,20 +1555,20 @@ func (s *ProjectService) RestartProject(ctx context.Context, projectID string, s
return resolveProjectComposeFileErr
}
- if updateProjectStatusErr := s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRestarting); updateProjectStatusErr != nil {
+ if updateProjectStatusErr := s.updateProjectStatus(ctx, projectID, ProjectStatusRestarting); updateProjectStatusErr != nil {
return fmt.Errorf("failed to update project status to restarting: %w", updateProjectStatusErr)
}
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
+ compProj, _, lerr := s.loadComposeProjectForProject(ctx, proj, nil)
if lerr != nil {
- _ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
+ _ = s.updateProjectStatus(ctx, projectID, ProjectStatusRunning)
return fmt.Errorf("failed to load compose project: %w", lerr)
}
defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
if composeRestartErr := projects.ComposeRestart(ctx, compProj, services); composeRestartErr != nil {
- _ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
+ _ = s.updateProjectStatus(ctx, projectID, ProjectStatusRunning)
return fmt.Errorf("failed to restart project: %w", composeRestartErr)
}
@@ -1716,16 +1580,16 @@ func (s *ProjectService) RestartProject(ctx context.Context, projectID string, s
if len(services) > 0 {
metadata["services"] = append([]string(nil), services...)
}
- s.logProjectEventInternal(ctx, event.EventTypeProjectStart, projectID, proj.Name, user, metadata, "could not log project restart action")
+ s.logProjectEvent(ctx, event.EventTypeProjectStart, projectID, proj.Name, user, metadata, "could not log project restart action")
- return s.updateProjectStatusandCountsInternal(ctx, projectID, ProjectStatusRunning)
+ return s.updateProjectStatusAndCounts(ctx, projectID, ProjectStatusRunning)
}
-func (s *ProjectService) updateProjectStatusandCountsInternal(ctx context.Context, projectID string, status ProjectStatus) error {
- services, err := s.projectServicesInternal(ctx, projectID)
+func (s *ProjectService) updateProjectStatusAndCounts(ctx context.Context, projectID string, status ProjectStatus) error {
+ services, err := s.projectServices(ctx, projectID)
if err != nil {
slog.ErrorContext(ctx, "loading project services failed during status update", "projectId", projectID, "error", err)
- return s.updateProjectStatusInternal(ctx, projectID, status)
+ return s.updateProjectStatus(ctx, projectID, status)
}
serviceCount, runningCount := listing.ServiceCounts(services)
@@ -1740,7 +1604,7 @@ func (s *ProjectService) updateProjectStatusandCountsInternal(ctx context.Contex
return nil
}
-func (s *ProjectService) updateProjectStatusInternal(ctx context.Context, id string, status ProjectStatus) error {
+func (s *ProjectService) updateProjectStatus(ctx context.Context, id string, status ProjectStatus) error {
now := time.Now()
res := s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", id).Updates(map[string]any{
"status": status,
@@ -1754,7 +1618,7 @@ func (s *ProjectService) updateProjectStatusInternal(ctx context.Context, id str
return nil
}
-func (s *ProjectService) GetProjectContent(ctx context.Context, projectID string) (composeContent, envContent, overrideContent string, err error) {
+func (s *ProjectService) projectContent(ctx context.Context, projectID string) (composeContent, envContent, overrideContent string, err error) {
proj, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
return "", "", "", err
@@ -1784,19 +1648,6 @@ func (s *ProjectService) GetProjectContent(ctx context.Context, projectID string
return composeContent, envContent, projects.ReadComposeOverrideContent(proj.Path), nil
}
-func (s *ProjectService) populateDetailsComposeContentInternal(ctx context.Context, proj *Project, opts projecttypes.DetailsOptions, composeSelection []string, resp *projecttypes.Details) error {
- if !opts.IncludeComposeContent {
- return nil
- }
- composeContent, _, overrideContent, err := s.GetProjectContent(ctx, proj.ID)
- if err != nil {
- return fmt.Errorf("failed to read project compose content: %w", err)
- }
- resp.ComposeContent = composeContent
- resp.OverrideFileName, resp.OverrideContent = projectdetails.ResolveDetailsOverride(proj.Path, overrideContent, composeSelection)
- return nil
-}
-
func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string, opts projecttypes.DetailsOptions) (projecttypes.Details, error) {
proj, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
@@ -1836,11 +1687,8 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
resp.RunningCount = proj.RunningCount
resp.Status = string(proj.Status)
- // COMPOSE_FILE in the project's .env selects the compose file set; when set,
- // `docker compose` skips auto-overrides and Arcane deploys exactly this list.
- // ComposeFiles is populated only for a multi-file selection. A broken
- // selection keeps the details response intact but logs the failure so the
- // configuration problem is diagnosable.
+ // COMPOSE_FILE selects the deployed file set (no auto-overrides). A broken
+ // selection is logged but keeps the details response intact.
composeSelection, selErr := projects.ComposeFileEnvSelection(ctx, projectsDir, proj.Path)
if selErr != nil {
selLogLevel := kit.Ternary(errors.Is(selErr, common.ErrProjectEnvUnreadable), slog.LevelDebug, slog.LevelWarn)
@@ -1850,8 +1698,13 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
resp.ComposeFiles = projectdetails.ComposeSelectionRelativePaths(proj.Path, composeSelection)
resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, proj.Path)
- if populateDetailsComposeContentErr := s.populateDetailsComposeContentInternal(ctx, proj, opts, composeSelection, &resp); populateDetailsComposeContentErr != nil {
- return projecttypes.Details{}, populateDetailsComposeContentErr
+ if opts.IncludeComposeContent {
+ composeContent, _, overrideContent, contentErr := s.projectContent(ctx, proj.ID)
+ if contentErr != nil {
+ return projecttypes.Details{}, fmt.Errorf("failed to read project compose content: %w", contentErr)
+ }
+ resp.ComposeContent = composeContent
+ resp.OverrideFileName, resp.OverrideContent = projectdetails.ResolveDetailsOverride(proj.Path, overrideContent, composeSelection)
}
if opts.IncludeEnvState {
envState, readProjectEnvStateErr := projects.ReadProjectEnvState(proj.Path)
@@ -1865,13 +1718,21 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
resp.EnvContent = effectiveEnvContent
}
- s.enrichComposeDetailsInternal(ctx, proj, opts, &resp)
- s.enrichWithGitOpsInfo(ctx, proj, &resp)
+ s.enrichComposeDetails(ctx, proj, opts, &resp)
+ if syncID := gitOpsSyncID(proj); syncID != "" {
+ var syncRecord GitOpsSync
+ if syncErr := s.db.WithContext(ctx).Preload("Repository").Where("id = ?", syncID).First(&syncRecord).Error; syncErr == nil {
+ resp.LastSyncCommit = syncRecord.LastSyncCommit
+ if syncRecord.Repository != nil {
+ resp.GitRepositoryURL = syncRecord.Repository.URL
+ }
+ }
+ }
// Refresh runtime status/counts even when callers do not request the full
// runtime service array. DB values are only a fallback when Docker lookup
// or compose loading fails.
- services, serr := s.projectServicesInternal(ctx, projectID)
+ services, serr := s.projectServices(ctx, projectID)
if serr == nil && services != nil {
resp.ServiceCount = len(services)
_, runningCount := listing.ServiceCounts(services)
@@ -1880,17 +1741,12 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
if opts.IncludeRuntimeServices || opts.IncludeUpdateInfo {
resp.RuntimeServices = services
- for _, svc := range services {
- if svc.RedeployDisabled {
- resp.RedeployDisabled = true
- break
- }
- }
+ resp.RedeployDisabled = slices.ContainsFunc(services, func(svc projecttypes.RuntimeService) bool { return svc.RedeployDisabled })
}
}
if opts.IncludeUpdateInfo {
- s.enrichProjectUpdateInfoInternal(ctx, &resp)
+ s.enrichProjectUpdateInfo(ctx, &resp)
}
if !opts.IncludeRuntimeServices {
resp.RuntimeServices = nil
@@ -1902,7 +1758,7 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
return resp, nil
}
-func (s *ProjectService) enrichProjectUpdateInfoInternal(ctx context.Context, resp *projecttypes.Details) {
+func (s *ProjectService) enrichProjectUpdateInfo(ctx context.Context, resp *projecttypes.Details) {
if resp == nil {
return
}
@@ -1928,21 +1784,21 @@ func (s *ProjectService) enrichProjectUpdateInfoInternal(ctx context.Context, re
resp.UpdateInfo = BuildConfiguredUpdateInfo(resp.ID, resp.Services, updateInfoByRef, records, projectdetails.ConfiguredRuntimeServiceUpdateInfo(resp.Services, resp.RuntimeServices, scoped))
return
}
- resp.UpdateInfo = BuildUpdateInfoSummary(imageRefs, projectdetails.MergeProjectContainerUpdateInfo(updateInfoByRef, resp.RuntimeServices, scoped))
+ resp.UpdateInfo = buildUpdateInfoSummary(imageRefs, projectdetails.MergeProjectContainerUpdateInfo(updateInfoByRef, resp.RuntimeServices, scoped))
}
-func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(
+func (s *ProjectService) enrichProjectsWithUpdateInfo(
ctx context.Context,
projectsList []Project,
details []projecttypes.Details,
includeHidden bool,
- env *projectMetadataEnvInternal,
+ env *projectMetadataEnv,
) {
if len(projectsList) == 0 || len(details) == 0 {
return
}
if env == nil {
- env = s.newProjectMetadataEnvInternal(ctx, projectsList)
+ env = s.newProjectMetadataEnv(ctx, projectsList)
}
var hiddenServicesByProjectID, hiddenRefsByProjectID map[string]map[string]bool
@@ -1950,48 +1806,44 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(
hiddenServicesByProjectID, hiddenRefsByProjectID = projectdetails.ExcludeHiddenRuntimeServices(details)
}
- imageRefsByProjectID := make(map[string][]string, len(projectsList))
- allImageRefs := make([]string, 0)
- servicesByProjectID := make(map[string][]types.ServiceConfig, len(projectsList))
- projectIDs := make([]string, 0, len(projectsList))
-
- type imageRefsResult struct {
- projectID string
- refs []string
- services []types.ServiceConfig
- }
-
- sem := make(chan struct{}, maxConcurrentComposeReads)
- resultsCh := make(chan imageRefsResult, len(projectsList))
-
- var wg sync.WaitGroup
- for _, proj := range projectsList {
- projectIDs = append(projectIDs, proj.ID)
-
- wg.Add(1)
- go func(proj Project) {
- defer wg.Done()
-
- select {
- case sem <- struct{}{}:
- case <-ctx.Done():
- return
+ // Bounded fan-out over compose loads; a cancelled request leaves the
+ // remaining projects without configured services.
+ refsByIndex := make([][]string, len(projectsList))
+ servicesByIndex := make([][]types.ServiceConfig, len(projectsList))
+ var g errgroup.Group
+ g.SetLimit(maxConcurrentComposeReads)
+ for i, proj := range projectsList {
+ g.Go(func() error {
+ if ctx.Err() != nil {
+ return nil
}
- defer func() { <-sem }()
-
- refs, services := s.resolveProjectUpdateServicesInternal(ctx, proj, env, includeHidden, hiddenServicesByProjectID[proj.ID], hiddenRefsByProjectID[proj.ID])
- resultsCh <- imageRefsResult{projectID: proj.ID, refs: refs, services: services}
- }(proj)
+ composeProject, err := s.getCachedComposeProject(ctx, &proj, env)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to resolve project services for update summary", "projectId", proj.ID, "projectName", proj.Name, "error", err)
+ refsByIndex[i] = slices.DeleteFunc(projects.ParseImageRefsJSON(proj.ImageRefsJSON), func(ref string) bool { return hiddenRefsByProjectID[proj.ID][ref] })
+ return nil
+ }
+ services := make([]types.ServiceConfig, 0, len(composeProject.Services))
+ for _, service := range composeProject.Services {
+ hidden, _ := kit.ParseBool(service.Labels[libarcane.HiddenResourceLabel])
+ if includeHidden || (!hidden && !hiddenServicesByProjectID[proj.ID][service.Name]) {
+ services = append(services, service)
+ }
+ }
+ refsByIndex[i], servicesByIndex[i] = projects.ImageRefsFromComposeConfigs(services), services
+ return nil
+ })
}
+ _ = g.Wait()
- wg.Wait()
- close(resultsCh)
-
- for result := range resultsCh {
- imageRefsByProjectID[result.projectID] = result.refs
- servicesByProjectID[result.projectID] = result.services
- allImageRefs = append(allImageRefs, result.refs...)
+ projectIDs := make([]string, len(projectsList))
+ imageRefsByProjectID := make(map[string][]string, len(projectsList))
+ servicesByProjectID := make(map[string][]types.ServiceConfig, len(projectsList))
+ for i, proj := range projectsList {
+ projectIDs[i] = proj.ID
+ imageRefsByProjectID[proj.ID], servicesByProjectID[proj.ID] = refsByIndex[i], servicesByIndex[i]
}
+ allImageRefs := slices.Concat(refsByIndex...)
var updateInfoByRef map[string]*imagetypes.UpdateInfo
if len(allImageRefs) > 0 && s.imageService != nil {
@@ -2003,7 +1855,10 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(
}
}
- recordsByProjectID := projectdetails.GroupUpdateRecordsByProject(s.details.ServiceUpdateRecords(ctx, projectIDs))
+ recordsByProjectID := make(map[string][]imageupdate.ImageUpdateRecord)
+ for _, record := range s.details.ServiceUpdateRecords(ctx, projectIDs) {
+ recordsByProjectID[record.ProjectID] = append(recordsByProjectID[record.ProjectID], record)
+ }
scoped := s.details.ContainerUpdateInfo(ctx, details)
for i := range details {
if services := servicesByProjectID[details[i].ID]; services != nil {
@@ -2024,39 +1879,10 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(
if len(refs) == 0 {
refs = projects.ImageRefsFromRuntimeServices(details[i].RuntimeServices)
}
- details[i].UpdateInfo = BuildUpdateInfoSummary(refs, projectdetails.MergeProjectContainerUpdateInfo(updateInfoByRef, details[i].RuntimeServices, scoped))
+ details[i].UpdateInfo = buildUpdateInfoSummary(refs, projectdetails.MergeProjectContainerUpdateInfo(updateInfoByRef, details[i].RuntimeServices, scoped))
}
}
-func (
- s *ProjectService,
-) resolveProjectUpdateServicesInternal(
- ctx context.Context,
- proj Project,
- env *projectMetadataEnvInternal,
- includeHidden bool,
- hiddenRuntimeServices, hiddenRuntimeRefs map[string]bool,
-) (
- []string,
- []types.ServiceConfig,
-) {
- composeProject, err := s.getCachedComposeProjectInternal(ctx, &proj, env)
- if err != nil {
- slog.WarnContext(ctx, "failed to resolve project services for update summary", "projectId", proj.ID, "projectName", proj.Name, "error", err)
- refs := projects.ParseImageRefsJSON(proj.ImageRefsJSON)
- return slices.DeleteFunc(refs, func(ref string) bool { return hiddenRuntimeRefs[ref] }), nil
- }
- services := make([]types.ServiceConfig, 0, len(composeProject.Services))
- for _, service := range composeProject.Services {
- hidden, _ := kit.ParseBool(service.Labels[libarcane.HiddenResourceLabel])
- if !includeHidden && (hidden || hiddenRuntimeServices[service.Name]) {
- continue
- }
- services = append(services, service)
- }
- return projects.ImageRefsFromComposeConfigs(services), services
-}
-
// BuildConfiguredUpdateInfo matches checks to current services and aggregates their results.
func BuildConfiguredUpdateInfo(
projectID string,
@@ -2090,11 +1916,8 @@ func BuildConfiguredUpdateInfo(
}
if len(runtimeUpdates) > 0 && runtimeUpdates[0][service.Name] != nil {
- // A runtime check at least as recent as the stored preview that
- // found nothing supersedes a preview still advertising an update;
- // the preview is only rewritten by a manual project check (#4306).
- // Digest checks share image IDs across references. Require a matching
- // check for the configured reference before clearing its preview.
+ // A newer clean runtime check clears a stale update preview (#4306);
+ // digest checks must match the configured reference to count.
runtime := runtimeUpdates[0][service.Name]
attributed := policyErr == nil && policy.Strategy != "digest"
if stored := byRef[imageRef]; policyErr == nil && !attributed && stored != nil && !stored.HasUpdate && stored.Error == "" && stored.CheckTime.Equal(runtime.CheckTime) {
@@ -2134,22 +1957,13 @@ func BuildConfiguredUpdateInfo(
delete(merged, imageRef)
}
}
- summary := BuildUpdateInfoSummary(projects.ImageRefsFromComposeConfigs(services), merged)
+ summary := buildUpdateInfoSummary(projects.ImageRefsFromComposeConfigs(services), merged)
summary.ServiceUpdates = serviceUpdates
return summary
}
-func (s *ProjectService) getProjectImageRefsFromComposeInternal(ctx context.Context, proj Project, env *projectMetadataEnvInternal) ([]string, []string, error) {
- composeProject, err := s.getCachedComposeProjectInternal(ctx, &proj, env)
- if err != nil {
- return nil, nil, fmt.Errorf("load compose project: %w", err)
- }
-
- return projects.ImageRefsFromComposeServices(composeProject.Services), projects.BuildImageRefsFromComposeProject(composeProject), nil
-}
-
-// BuildUpdateInfoSummary aggregates image checks into a project update summary.
-func BuildUpdateInfoSummary(
+// buildUpdateInfoSummary aggregates image checks into a project update summary.
+func buildUpdateInfoSummary(
imageRefs []string,
updateInfoByRef map[string]*imagetypes.UpdateInfo,
) *projecttypes.UpdateInfo {
@@ -2216,19 +2030,7 @@ func BuildUpdateInfoSummary(
return summary
}
-func (s *ProjectService) enrichWithGitOpsInfo(ctx context.Context, proj *Project, resp *projecttypes.Details) {
- if proj.GitOpsManagedBy != nil {
- var syncRecord GitOpsSync
- if err := s.db.WithContext(ctx).Preload("Repository").Where("id = ?", *proj.GitOpsManagedBy).First(&syncRecord).Error; err == nil {
- resp.LastSyncCommit = syncRecord.LastSyncCommit
- if syncRecord.Repository != nil {
- resp.GitRepositoryURL = syncRecord.Repository.URL
- }
- }
- }
-}
-
-func (s *ProjectService) enrichComposeDetailsInternal(ctx context.Context, proj *Project, opts projecttypes.DetailsOptions, resp *projecttypes.Details) {
+func (s *ProjectService) enrichComposeDetails(ctx context.Context, proj *Project, opts projecttypes.DetailsOptions, resp *projecttypes.Details) {
composeFile, err := s.ResolveProjectComposeFile(ctx, proj)
if err != nil {
if !errors.Is(err, common.ErrProjectEnvUnreadable) {
@@ -2258,7 +2060,7 @@ func (s *ProjectService) enrichComposeDetailsInternal(ctx context.Context, proj
return
}
- composeProj, loadErr := s.getCachedComposeProjectInternal(ctx, proj, nil)
+ composeProj, loadErr := s.getCachedComposeProject(ctx, proj, nil)
if loadErr != nil {
slog.WarnContext(ctx, "failed to load compose service configs", "path", composeFile, "error", loadErr)
return
@@ -2282,7 +2084,7 @@ func (s *ProjectService) enrichComposeDetailsInternal(ctx context.Context, proj
}
func (s *ProjectService) CountServicesFromCompose(ctx context.Context, p Project) (int, error) {
- proj, _, err := s.loadComposeProjectForProjectInternal(ctx, &p, nil)
+ proj, _, err := s.loadComposeProjectForProject(ctx, &p, nil)
if err != nil {
return 0, err
}
@@ -2290,22 +2092,6 @@ func (s *ProjectService) CountServicesFromCompose(ctx context.Context, p Project
return len(proj.Services), nil
}
-// projectServicesFromContainersInternal derives runtime services from labeled
-// containers for projects whose Compose file cannot be loaded.
-func (s *ProjectService) projectServicesFromContainersInternal(ctx context.Context, proj *Project, meta projects.ArcaneComposeMetadata) ([]projecttypes.RuntimeService, error) {
- containers, err := s.details.ComposeContainers(ctx)
- if err != nil {
- return nil, err
- }
- matched := listing.ProjectContainers(projectRecordInternal(*proj), listing.GroupComposeContainersByProject(containers))
- currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
- services := make([]projecttypes.RuntimeService, 0, len(matched))
- for _, c := range matched {
- services = append(services, listing.RuntimeServiceFromContainer(IconCatalogForContext(ctx), c, meta, currentContainerID, currentContainerErr))
- }
- return services, nil
-}
-
func (s *ProjectService) ListAllProjects(ctx context.Context) ([]Project, error) {
var items []Project
if err := s.db.WithContext(ctx).Find(&items).Error; err != nil {
@@ -2314,134 +2100,114 @@ func (s *ProjectService) ListAllProjects(ctx context.Context) ([]Project, error)
return items, nil
}
-func (s *ProjectService) countProjectFolders(ctx context.Context) (int, error) {
- followProjectSymlinks := s.settingsService.GetBoolSetting(ctx, "followProjectSymlinks", false)
- projectsDir, err := s.GetProjectsDirectory(ctx)
- if err != nil {
- return 0, fmt.Errorf("could not determine projects directory: %w", err)
- }
-
- // os.* rather than acfs: this probes the projects directory itself, which is
- // the confinement root and may not exist yet.
- info, statErr := os.Stat(projectsDir)
- if os.IsNotExist(statErr) {
- // Directory missing, treat as zero
- return 0, nil
- }
- if statErr != nil {
- return 0, fmt.Errorf("unable to access projects directory %s: %w", projectsDir, statErr)
- }
- if !info.IsDir() {
- return 0, nil
- }
-
- discoveredProjects, discoveryErr := projects.DiscoverProjectDirectories(ctx, projectsDir, followProjectSymlinks, s.config.ProjectScanMaxDepth)
- if discoveryErr != nil {
- return 0, fmt.Errorf("failed to discover project directories in %s: %w", projectsDir, discoveryErr)
- }
-
- return len(discoveredProjects), nil
-}
-
func (s *ProjectService) ListProjects(ctx context.Context, params pagination.QueryParams) ([]projecttypes.Details, pagination.Response, error) {
+ statusFilter := strings.TrimSpace(params.Filters["status"])
+ updatesFilter := strings.TrimSpace(params.Filters["updates"])
+ labelFilter := strings.TrimSpace(params.Filters["label"])
query := s.db.WithContext(ctx).Model(&Project{})
- statusFilter := ""
- updatesFilter := ""
- archivedFilter := ""
- tagsFilter := ""
- labelFilter := ""
- if params.Filters != nil {
- statusFilter = strings.TrimSpace(params.Filters["status"])
- updatesFilter = strings.TrimSpace(params.Filters["updates"])
- archivedFilter = strings.TrimSpace(params.Filters["archived"])
- tagsFilter = strings.TrimSpace(params.Filters["tags"])
- labelFilter = strings.TrimSpace(params.Filters["label"])
- }
- query = listing.ApplyProjectArchivedDBFilter(query, archivedFilter)
- query = listing.ApplyProjectTagsDBFilter(query, tagsFilter)
- sortsByDerivedStatus := strings.EqualFold(strings.TrimSpace(params.Sort), "status")
- if statusFilter != "" || updatesFilter != "" || labelFilter != "" || sortsByDerivedStatus {
- return s.listProjectsWithDerivedFiltersInternal(ctx, params, query)
+ if archivedFilter := strings.TrimSpace(params.Filters["archived"]); !strings.EqualFold(archivedFilter, "all") {
+ archived, _ := kit.ParseBool(archivedFilter)
+ query = query.Where("is_archived = ?", archived)
}
-
+ query = listing.ApplyProjectTagsDBFilter(query, strings.TrimSpace(params.Filters["tags"]))
if term := strings.TrimSpace(params.Search); term != "" {
- query = listing.ApplyProjectSearchDBFilter(query, term)
- }
-
- query = pagination.ApplyFilter(query, "status", params.Filters["status"])
-
- var projectsArray []Project
- paginationResp, err := pagination.PaginateAndSortDB(params, query, &projectsArray)
- if err != nil {
- return nil, pagination.Response{}, fmt.Errorf("failed to paginate projects: %w", err)
+ pattern := "%" + term + "%"
+ query = query.Where(
+ "name LIKE ? OR path LIKE ? OR status LIKE ? OR COALESCE(dir_name, '') LIKE ? OR "+
+ "EXISTS (SELECT 1 FROM project_tags WHERE project_tags.project_id = projects.id AND LOWER(project_tags.name) LIKE ?)",
+ pattern, pattern, pattern, pattern, strings.ToLower(pattern),
+ )
}
- slog.DebugContext(ctx, "Retrieved projects from database",
- "count", len(projectsArray))
-
- // Fetch live status concurrently for all projects
- env := s.newProjectMetadataEnvInternal(ctx, projectsArray)
- result := s.fetchProjectStatusConcurrently(ctx, projectsArray, env)
- if enrichProjectsWithTagsErr := s.enrichProjectsWithTagsInternal(ctx, result); enrichProjectsWithTagsErr != nil {
- return nil, pagination.Response{}, enrichProjectsWithTagsErr
+ if statusFilter == "" && updatesFilter == "" && labelFilter == "" && !strings.EqualFold(strings.TrimSpace(params.Sort), "status") {
+ query = pagination.ApplyFilter(query, "status", params.Filters["status"])
+ var projectsArray []Project
+ paginationResp, err := pagination.PaginateAndSortDB(params, query, &projectsArray)
+ if err != nil {
+ return nil, pagination.Response{}, fmt.Errorf("failed to paginate projects: %w", err)
+ }
+ slog.DebugContext(ctx, "Retrieved projects from database", "count", len(projectsArray))
+
+ // The paginated page gets live status from one Docker snapshot plus the
+ // compose-backed presentation fields, sharing one metadata env.
+ env := s.newProjectMetadataEnv(ctx, projectsArray)
+ result := s.projectListRows(ctx, env.projectsDirectory, projectsArray, s.listing.Snapshot(ctx))
+ metas := make([]projects.ArcaneComposeMetadata, len(projectsArray))
+ var metaGroup errgroup.Group
+ metaGroup.SetLimit(maxConcurrentComposeReads)
+ for i := range projectsArray {
+ metaGroup.Go(func() (workerErr error) {
+ defer utils.RecoverToError(&workerErr, "project metadata worker", "projectID", projectsArray[i].ID)
+ metas[i] = s.ProjectMetadata(ctx, projectsArray[i], env)
+ return nil
+ })
+ }
+ if metaErr := metaGroup.Wait(); metaErr != nil {
+ slog.WarnContext(ctx, "project metadata resolution failed", "error", metaErr)
+ }
+ listing.ApplyPresentation(ctx, env.projectsDirectory, IconCatalogForContext(ctx), projectRecords(projectsArray), result, metas)
+ pageIDs := make([]string, len(projectsArray))
+ for i, proj := range projectsArray {
+ pageIDs[i] = proj.ID
+ }
+ var tagRows []projecttypes.TagAssignment
+ if tagsErr := s.db.WithContext(ctx).Model(&ProjectTag{}).Where("project_id IN ?", pageIDs).Order("project_id, name, source, color").Find(&tagRows).Error; tagsErr != nil {
+ return nil, pagination.Response{}, fmt.Errorf("load project tags: %w", tagsErr)
+ }
+ tagsByProject := tags.Group(tagRows)
+ for i := range result {
+ result[i].Tags = tagsByProject[result[i].ID]
+ }
+ s.enrichProjectsWithUpdateInfo(ctx, projectsArray, result, true, env)
+ slog.DebugContext(ctx, "Completed ListProjects request", "resultCount", len(result))
+ return result, paginationResp, nil
}
- s.enrichProjectsWithUpdateInfoInternal(ctx, projectsArray, result, true, env)
-
- slog.DebugContext(ctx, "Completed ListProjects request",
- "resultCount", len(result))
-
- return result, paginationResp, nil
-}
-func (s *ProjectService) listProjectsWithDerivedFiltersInternal(
- ctx context.Context,
- params pagination.QueryParams,
- query *gorm.DB,
-) ([]projecttypes.Details, pagination.Response, error) {
- params = listing.ClampDerivedLimit(params)
-
- result, err := s.filterProjectsWithDerivedFiltersInternal(ctx, params, query)
- if err != nil {
- return nil, pagination.Response{}, err
+ // Derived filters and status sorting read the container snapshot, so every
+ // candidate gets a lean row and the compose-backed presentation fields are
+ // resolved for the page alone.
+ if params.Limit != -1 {
+ params.Limit = kit.Ternary(params.Limit <= 0, 20, min(params.Limit, 100))
}
- paginationResp := pagination.BuildResponse(result.TotalCount, result.TotalAvailable, params)
-
- return result.Items, paginationResp, nil
-}
-
-func (s *ProjectService) filterProjectsWithDerivedFiltersInternal(
- ctx context.Context,
- params pagination.QueryParams,
- query *gorm.DB,
-) (pagination.FilterResult[projecttypes.Details], error) {
var projectsArray []Project
- if term := strings.TrimSpace(params.Search); term != "" {
- query = listing.ApplyProjectSearchDBFilter(query, term)
- }
if err := query.Find(&projectsArray).Error; err != nil {
- return pagination.FilterResult[projecttypes.Details]{}, fmt.Errorf("failed to list projects: %w", err)
+ return nil, pagination.Response{}, fmt.Errorf("failed to list projects: %w", err)
}
-
- // Filtering, searching, and sorting only read database columns, tags, and
- // the container snapshot, so every candidate gets a lean row and the
- // compose-backed presentation fields are resolved for the page alone.
- env := s.newProjectMetadataEnvInternal(ctx, nil)
+ env := s.newProjectMetadataEnv(ctx, nil)
snapshot := s.listing.Snapshot(ctx)
- items := s.projectListRowsInternal(ctx, env.projectsDirectory, projectsArray, snapshot)
- if err := s.enrichProjectsWithTagsInternal(ctx, items); err != nil {
- return pagination.FilterResult[projecttypes.Details]{}, err
- }
- updatesFiltered := strings.TrimSpace(params.Filters["updates"]) != ""
- if updatesFiltered {
- s.preloadGitOpsComposePathsInternal(ctx, env, projectsArray)
- s.enrichProjectsWithUpdateInfoInternal(ctx, projectsArray, items, true, env)
- items = s.appendDiscoveredComposeProjectUpdatesInternal(ctx, params, projectsArray, items, snapshot)
- }
-
+ items := s.projectListRows(ctx, env.projectsDirectory, projectsArray, snapshot)
byID := make(map[string]Project, len(projectsArray))
for _, proj := range projectsArray {
byID[proj.ID] = proj
}
+ var tagRows []projecttypes.TagAssignment
+ if tagsErr := s.db.WithContext(ctx).Model(&ProjectTag{}).Where("project_id IN ?", slices.Collect(maps.Keys(byID))).Order("project_id, name, source, color").Find(&tagRows).Error; tagsErr != nil {
+ return nil, pagination.Response{}, fmt.Errorf("load project tags: %w", tagsErr)
+ }
+ tagsByProject := tags.Group(tagRows)
+ for i := range items {
+ items[i].Tags = tagsByProject[items[i].ID]
+ }
+ if updatesFilter != "" {
+ s.preloadGitOpsComposePaths(ctx, env, projectsArray)
+ s.enrichProjectsWithUpdateInfo(ctx, projectsArray, items, true, env)
+ // Untracked compose projects only join an unfiltered-by-tag has_update view.
+ if strings.EqualFold(updatesFilter, "has_update") && strings.TrimSpace(params.Filters["tags"]) == "" {
+ if snapshot.Err != nil {
+ slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", snapshot.Err)
+ } else {
+ // Every tracked project name is known; the candidates cover a failed lookup.
+ var knownProjects []Project
+ if knownErr := s.db.WithContext(ctx).Select("name", "compose_project_name").Find(&knownProjects).Error; knownErr != nil {
+ slog.WarnContext(ctx, "failed to load known project names for compose update discovery", "error", knownErr)
+ knownProjects = projectsArray
+ }
+ known := listing.KnownComposeProjectNames(projectRecords(knownProjects))
+ items = append(items, s.listing.DiscoveredUpdateRows(ctx, snapshot.Containers, known, IconCatalogForContext(ctx))...)
+ }
+ }
+ }
+
result, pageIndexes := listing.Page(items, params, func(id string) bool {
_, tracked := byID[id]
return tracked
@@ -2452,26 +2218,33 @@ func (s *ProjectService) filterProjectsWithDerivedFiltersInternal(
pageProjects = append(pageProjects, byID[result.Items[i].ID])
pageDetails = append(pageDetails, result.Items[i])
}
- if !updatesFiltered {
- s.preloadGitOpsComposePathsInternal(ctx, env, pageProjects)
- s.enrichProjectsWithUpdateInfoInternal(ctx, pageProjects, pageDetails, true, env)
+ if updatesFilter == "" {
+ s.preloadGitOpsComposePaths(ctx, env, pageProjects)
+ s.enrichProjectsWithUpdateInfo(ctx, pageProjects, pageDetails, true, env)
+ }
+ metas := make([]projects.ArcaneComposeMetadata, len(pageProjects))
+ var metaGroup errgroup.Group
+ metaGroup.SetLimit(maxConcurrentComposeReads)
+ for i := range pageProjects {
+ metaGroup.Go(func() (workerErr error) {
+ defer utils.RecoverToError(&workerErr, "project metadata worker", "projectID", pageProjects[i].ID)
+ metas[i] = s.ProjectMetadata(ctx, pageProjects[i], env)
+ return nil
+ })
+ }
+ if metaErr := metaGroup.Wait(); metaErr != nil {
+ slog.WarnContext(ctx, "project metadata resolution failed", "error", metaErr)
}
- s.applyProjectPresentationInternal(ctx, pageProjects, pageDetails, env)
+ listing.ApplyPresentation(ctx, env.projectsDirectory, IconCatalogForContext(ctx), projectRecords(pageProjects), pageDetails, metas)
for k, i := range pageIndexes {
result.Items[i] = pageDetails[k]
}
- return result, nil
+ return result.Items, pagination.BuildResponse(result.TotalCount, result.TotalAvailable, params), nil
}
-// CountProjectsWithPendingUpdates counts non-archived projects with at
-// least one visible service with an image update pending, plus compose projects running on the daemon
-// that Arcane does not track. It deliberately avoids the project-list pipeline:
-// that path builds full project DTOs (live status, icons, URLs, GitOps lookups)
-// and then throws all of them away for a single number, costing several full
-// container lists and a compose parse per project on every dashboard load.
-//
-// allContainers is the caller's already-fetched container list; pass nil to have
-// it fetched here.
+// CountProjectsWithPendingUpdates counts active projects and untracked compose
+// projects with a pending update, without the full list pipeline. A nil
+// allContainers is fetched here.
func (s *ProjectService) CountProjectsWithPendingUpdates(ctx context.Context, allContainers []container.Summary) (int, error) {
if s.db == nil {
return 0, nil
@@ -2505,7 +2278,7 @@ func (s *ProjectService) CountProjectsWithPendingUpdates(ctx context.Context, al
containersByProject := listing.GroupComposeContainersByProject(allContainers)
for i, proj := range activeProjects {
details[i].ID = proj.ID
- for _, c := range listing.ProjectContainers(projectRecordInternal(proj), containersByProject) {
+ for _, c := range listing.ProjectContainers(projectRecord(proj), containersByProject) {
details[i].RuntimeServices = append(
details[i].RuntimeServices,
projecttypes.RuntimeService{
@@ -2520,7 +2293,7 @@ func (s *ProjectService) CountProjectsWithPendingUpdates(ctx context.Context, al
)
}
}
- s.enrichProjectsWithUpdateInfoInternal(ctx, activeProjects, details, false, nil)
+ s.enrichProjectsWithUpdateInfo(ctx, activeProjects, details, false, nil)
count := 0
for i := range details {
@@ -2536,91 +2309,21 @@ func (s *ProjectService) CountProjectsWithPendingUpdates(ctx context.Context, al
visibleContainers = append(visibleContainers, c)
}
}
- return count + s.countDiscoveredComposeProjectUpdatesInternal(ctx, allProjects, true, visibleContainers), nil
-}
-
-// fetchProjectStatusConcurrently builds complete list rows for an already
-// paginated page: live status from a single Docker API call plus the
-// compose-backed presentation fields. metaEnv is resolved once for the whole
-// list: ProjectMetadata would otherwise re-stat the projects directory,
-// re-clone settings, and re-query GitOps compose paths per project.
-func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, projectsList []Project, metaEnv *projectMetadataEnvInternal) []projecttypes.Details {
- results := s.projectListRowsInternal(ctx, metaEnv.projectsDirectory, projectsList, s.listing.Snapshot(ctx))
- s.applyProjectPresentationInternal(ctx, projectsList, results, metaEnv)
- return results
-}
-
-func (s *ProjectService) resolveProjectMetadataConcurrentlyInternal(ctx context.Context, projectsList []Project, metaEnv *projectMetadataEnvInternal) []projects.ArcaneComposeMetadata {
- metas := make([]projects.ArcaneComposeMetadata, len(projectsList))
- var g errgroup.Group
- g.SetLimit(maxConcurrentComposeReads)
- for i := range projectsList {
- g.Go(func() (workerErr error) {
- defer utils.RecoverToError(&workerErr, "project metadata worker", "projectID", projectsList[i].ID)
- metas[i] = s.ProjectMetadata(ctx, projectsList[i], metaEnv)
- return nil
- })
- }
- if err := g.Wait(); err != nil {
- slog.WarnContext(ctx, "project metadata resolution failed", "error", err)
- }
- return metas
-}
-
-// persistInferredServiceCountsInternal writes service counts inferred from live
-// containers back to projects whose stored count is still zero. The plain list
-// path sorts and paginates on the service_count column in SQL before rows are
-// enriched, so a count that only lives in the response leaves those projects
-// on the wrong page until a filesystem sync parses their compose file. The
-// write runs synchronously on the request context as one batched statement
-// per chunk: it only fires for projects that still have a zero count, so it is
-// cheap and needs no detached goroutine. Failures are logged; the response
-// already carries the inferred value.
-func (s *ProjectService) persistInferredServiceCountsInternal(ctx context.Context, counts map[string]int) {
- if len(counts) == 0 || s.db == nil {
- return
- }
- ids := slices.Collect(maps.Keys(counts))
- for chunk := range slices.Chunk(ids, inferredServiceCountBatchSizeInternal) {
- var caseExpr strings.Builder
- args := make([]any, 0, 2*len(chunk))
- caseExpr.WriteString("CASE id")
- for _, id := range chunk {
- caseExpr.WriteString(" WHEN ? THEN ?")
- args = append(args, id, counts[id])
- }
- caseExpr.WriteString(" ELSE service_count END")
- if err := s.db.WithContext(ctx).Model(&Project{}).
- Where("id IN ? AND service_count = 0", chunk).
- Update("service_count", gorm.Expr(caseExpr.String(), args...)).Error; err != nil {
- slog.WarnContext(ctx, "failed to persist inferred project service counts", "count", len(chunk), "error", err)
- return
- }
- }
+ // Untracked compose projects with a pending update count too, so the
+ // dashboard badge matches the projects table.
+ known := listing.KnownComposeProjectNames(projectRecords(allProjects))
+ return count + s.listing.CountDiscoveredUpdates(ctx, visibleContainers, known, IconCatalogForContext(ctx)), nil
}
-// inferredServiceCountBatchSizeInternal bounds the ids in one inferred
-// service count update so the statement stays under SQLite's bound variable
-// limit (two placeholders per id in the CASE plus one in the IN list).
-const inferredServiceCountBatchSizeInternal = 200
-
-// ProjectMetadata resolves a project's icon sets and service URLs.
-// Results are cached until any compose file the parse merged (root, COMPOSE_FILE
-// entries, override, includes) or any env file it read changes on disk,
-// because deriving them is expensive (compose load with
-// interpolation and .env reads, plus a gitops_syncs query for GitOps-managed
-// projects) and every project row on the list page needs it.
-//
-// env may be nil, in which case the projects directory and autoInjectEnv setting
-// are resolved here; callers iterating over many projects should resolve them
-// once and pass them in.
-func (s *ProjectService) ProjectMetadata(ctx context.Context, p Project, env *projectMetadataEnvInternal) projects.ArcaneComposeMetadata {
+// ProjectMetadata resolves a project's icon sets and service URLs, cached until
+// a merged compose or env file changes. A nil env resolves the shared inputs here.
+func (s *ProjectService) ProjectMetadata(ctx context.Context, p Project, env *projectMetadataEnv) projects.ArcaneComposeMetadata {
empty := projects.ArcaneComposeMetadata{ServiceIconSets: map[string]projects.IconSet{}}
if env == nil {
- env = s.newProjectMetadataEnvInternal(ctx, []Project{p})
+ env = s.newProjectMetadataEnv(ctx, []Project{p})
}
- composeFile, err := s.resolveProjectComposeFileInternal(ctx, &p, env)
+ composeFile, err := s.resolveProjectComposeFile(ctx, &p, env)
if err != nil {
return empty
}
@@ -2659,13 +2362,13 @@ func IconCatalogForContext(ctx context.Context) string {
return iconcatalog.DefaultCatalog
}
-func (s *ProjectService) refreshProjectImageRefsInternal(ctx context.Context, proj *Project) {
+func (s *ProjectService) refreshProjectImageRefs(ctx context.Context, proj *Project) {
if proj == nil || proj.ID == "" {
return
}
- s.invalidateProjectCachesInternal(proj.ID)
- refs, buildRefs, err := s.getProjectImageRefsFromComposeInternal(ctx, *proj, nil)
+ s.invalidateProjectCaches(proj.ID)
+ composeProject, err := s.getCachedComposeProject(ctx, proj, nil)
if err != nil {
if dbErr := s.db.WithContext(ctx).
Model(&Project{}).
@@ -2678,11 +2381,11 @@ func (s *ProjectService) refreshProjectImageRefsInternal(ctx context.Context, pr
}
proj.ImageRefsJSON = ""
proj.BuildImageRefsJSON = nil
- slog.WarnContext(ctx, "failed to refresh project image refs", "projectId", proj.ID, "projectName", proj.Name, "error", err)
+ slog.WarnContext(ctx, "failed to refresh project image refs", "projectId", proj.ID, "projectName", proj.Name, "error", fmt.Errorf("load compose project: %w", err))
return
}
- imageRefsJSON := projects.MarshalImageRefsJSON(refs)
- buildImageRefsJSON := cmp.Or(projects.MarshalImageRefsJSON(buildRefs), "[]")
+ imageRefsJSON := projects.MarshalImageRefsJSON(projects.ImageRefsFromComposeServices(composeProject.Services))
+ buildImageRefsJSON := cmp.Or(projects.MarshalImageRefsJSON(projects.BuildImageRefsFromComposeProject(composeProject)), "[]")
if persistImageRefsErr := s.db.WithContext(ctx).
Model(&Project{}).
Where("id = ?", proj.ID).
@@ -2702,16 +2405,22 @@ func (s *ProjectService) HandleProjectFilesChanged(ctx context.Context, paths []
return
}
- affected, err := s.resolveProjectsByChangedPathsInternal(ctx, paths)
- if err != nil {
- slog.WarnContext(ctx, "failed to resolve changed project files", "error", err)
+ var projectsList []Project
+ if err := s.db.WithContext(ctx).Find(&projectsList).Error; err != nil {
+ slog.WarnContext(ctx, "failed to resolve changed project files", "error", fmt.Errorf("list projects for changed paths: %w", err))
return
}
- for i := range affected {
- s.invalidateProjectCachesInternal(affected[i].ID)
- s.refreshProjectImageRefsInternal(ctx, &affected[i])
- if reconcileComposeTagsForProjectErr := s.reconcileComposeTagsForProjectInternal(ctx, &affected[i]); reconcileComposeTagsForProjectErr != nil {
- slog.WarnContext(ctx, "failed to reconcile Compose project tags after file change", "projectId", affected[i].ID, "error", reconcileComposeTagsForProjectErr)
+ for i := range projectsList {
+ projectPath := filepath.Clean(projectsList[i].Path)
+ if !slices.ContainsFunc(paths, func(changedPath string) bool {
+ changedPath = filepath.Clean(changedPath)
+ return changedPath == projectPath || strings.HasPrefix(changedPath, projectPath+string(os.PathSeparator))
+ }) {
+ continue
+ }
+ s.refreshProjectImageRefs(ctx, &projectsList[i])
+ if err := s.reconcileComposeTagsForProject(ctx, &projectsList[i]); err != nil {
+ slog.WarnContext(ctx, "failed to reconcile Compose project tags after file change", "projectId", projectsList[i].ID, "error", err)
}
}
}
@@ -2731,36 +2440,11 @@ func (s *ProjectService) BackfillProjectImageRefs(ctx context.Context) (int, err
if err := ctx.Err(); err != nil {
return i, err
}
- s.refreshProjectImageRefsInternal(ctx, &projectsList[i])
+ s.refreshProjectImageRefs(ctx, &projectsList[i])
}
return len(projectsList), nil
}
-func (s *ProjectService) resolveProjectsByChangedPathsInternal(ctx context.Context, paths []string) ([]Project, error) {
- var projectsList []Project
- if err := s.db.WithContext(ctx).Find(&projectsList).Error; err != nil {
- return nil, fmt.Errorf("list projects for changed paths: %w", err)
- }
-
- seen := make(map[string]struct{})
- affected := make([]Project, 0)
- for _, changedPath := range paths {
- cleanChangedPath := filepath.Clean(changedPath)
- for _, proj := range projectsList {
- projectPath := filepath.Clean(proj.Path)
- if cleanChangedPath != projectPath && !strings.HasPrefix(cleanChangedPath, projectPath+string(os.PathSeparator)) {
- continue
- }
- if _, ok := seen[proj.ID]; ok {
- continue
- }
- seen[proj.ID] = struct{}{}
- affected = append(affected, proj)
- }
- }
- return affected, nil
-}
-
func (s *ProjectService) SyncProjectsFromFileSystem(ctx context.Context) error {
// Serialized because the walk and the cleanup are two halves of one
// decision: overlapping syncs let an older walk's cleanup delete a project a
@@ -2787,7 +2471,7 @@ func (s *ProjectService) SyncProjectsFromFileSystem(ctx context.Context) error {
renameSyncState := s.updates.SyncState(ctx)
seen := map[string]struct{}{}
for _, discoveredProject := range discoveredProjects {
- if renameSyncState.SkipDiscoveredPath(discoveredProject.Path) {
+ if _, renameTarget := renameSyncState.SkipDiscoveredPaths[filepath.Clean(discoveredProject.Path)]; renameTarget {
continue
}
if uerr := s.upsertProjectForDir(ctx, discoveredProject.DirName, discoveredProject.Path); uerr != nil {
@@ -2796,12 +2480,66 @@ func (s *ProjectService) SyncProjectsFromFileSystem(ctx context.Context) error {
}
seen[discoveredProject.Path] = struct{}{}
}
- renameSyncState.MarkProtectedPathsSeen(seen)
+ maps.Copy(seen, renameSyncState.ProtectSeenPaths)
- if cerr := s.cleanupDBProjectsInternal(ctx, seen, followProjectSymlinks, projectsDir, s.config.ProjectScanMaxDepth); cerr != nil {
- slog.WarnContext(ctx, "error during DB cleanup of projects", "error", cerr)
+ // Decide deletions before performing any, so the mass-wipe guard can veto a
+ // suspicious pass (e.g. an unmounted projects volume) as a whole.
+ var all []Project
+ if findErr := s.db.WithContext(ctx).Find(&all).Error; findErr != nil {
+ slog.WarnContext(ctx, "error during DB cleanup of projects", "error", fmt.Errorf("list projects for cleanup failed: %w", findErr))
+ return nil
+ }
+ candidates := 0
+ var deletions, pendingDeletions []projectCleanupDecision
+ for _, p := range all {
+ if _, ok := seen[p.Path]; ok {
+ continue
+ }
+ // GitOps owns these projects' lifecycle: their compose files may not exist
+ // yet during a sync or after an SSH/clone failure.
+ if gitOpsSyncID(&p) != "" {
+ continue
+ }
+ // Rows imported from Arcane's own scratch dirs (project-update preview/backup,
+ // GitOps stage/backup) or from filesystem snapshot/trash dirs are never real
+ // projects. The decision is name-based, so it bypasses the mass-wipe guard.
+ if projects.IsInternalScratchDirName(p.Name) || projects.IsInternalScratchDirName(filepath.Base(p.Path)) || (p.DirName != nil && projects.IsInternalScratchDirName(*p.DirName)) {
+ deletions = append(deletions, projectCleanupDecision{project: p, reason: "removed internal Arcane scratch record (project-update/gitops temp dir)"})
+ continue
+ }
+ if rel := listing.RelativePath(projectsDir, p.Path); rel != "" && projects.PathContainsSnapshotDirectory(rel) {
+ deletions = append(deletions, projectCleanupDecision{project: p, reason: "removed project inside a filesystem snapshot/trash directory"})
+ continue
+ }
+ candidates++
+ if decision, remove := s.evaluateProjectCleanup(ctx, p, followProjectSymlinks, projectsDir, s.config.ProjectScanMaxDepth).Get(); remove {
+ pendingDeletions = append(pendingDeletions, decision)
+ }
+ }
+ // Pruning more than one project and over half the candidates usually means an
+ // unmounted or mis-mapped projects directory, so that pass keeps every record.
+ if len(pendingDeletions) <= 1 || len(pendingDeletions)*2 <= candidates {
+ deletions = append(deletions, pendingDeletions...)
+ } else {
+ slog.WarnContext(ctx,
+ "skipping project cleanup: this reconcile would delete most projects in a single pass, which usually "+
+ "means the projects directory is empty, unmounted, or mis-mapped; preserving DB records — check the "+
+ "projects volume is mounted and mapped correctly",
+ "wouldDelete", len(pendingDeletions),
+ "cleanupCandidates", candidates,
+ "projectsDir", projectsDir,
+ )
}
+ // Every removal is logged so this destructive reconcile leaves an audit trail.
+ for _, decision := range deletions {
+ p := decision.project
+ if deleteErr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { return deleteProjectWithTags(tx, p.ID) }); deleteErr != nil {
+ slog.ErrorContext(ctx, "failed to delete project during filesystem cleanup", "projectId", p.ID, "name", p.Name, "path", p.Path, "reason", decision.reason, "error", deleteErr)
+ continue
+ }
+ slog.WarnContext(ctx, "deleted project during filesystem cleanup", "projectId", p.ID, "name", p.Name, "path", p.Path, "reason", decision.reason)
+ }
return nil
}
@@ -2811,7 +2549,13 @@ func (s *ProjectService) upsertProjectForDir(ctx context.Context, dirName, dirPa
Where("path = ?", dirPath).
First(&existing).Error
- composeMetadata, serviceCountErr := s.loadComposeMetadataForSyncInternal(ctx, dirPath, dirName)
+ cfg := s.settingsService.GetSettingsOrDefaults(ctx)
+ composeMetadata := projecttypes.ComposeIdentity{ResolvedProjectName: projects.NormalizeProjectName(dirName)}
+ projectsDirectory, serviceCountErr := projects.GetProjectsDirectory(ctx, cfg.ProjectsDirectory.Value)
+ if serviceCountErr == nil {
+ autoInjectEnv := kit.ParseOrDefault(cfg.AutoInjectEnv.Value, false, strconv.ParseBool)
+ composeMetadata, serviceCountErr = projectsync.LoadComposeMetadata(ctx, dirPath, dirName, projectsDirectory, autoInjectEnv, s.projectPathMapper(ctx))
+ }
serviceCountLogLevel := kit.Ternary(errors.Is(serviceCountErr, common.ErrProjectEnvUnreadable), slog.LevelDebug, slog.LevelWarn)
if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -2837,8 +2581,15 @@ func (s *ProjectService) upsertProjectForDir(ctx context.Context, dirName, dirPa
if cerr := s.db.WithContext(ctx).Create(proj).Error; cerr != nil {
return fmt.Errorf("create project for %q failed: %w", dirPath, cerr)
}
- s.warnDuplicateComposeNameForPathInternal(ctx, composeMetadata.ResolvedProjectName, dirPath, proj.ID)
- return s.reconcileComposeTagsForProjectInternal(ctx, proj)
+ if composeName := composeMetadata.ResolvedProjectName; strings.TrimSpace(composeName) != "" {
+ var duplicates int64
+ if countErr := s.db.WithContext(ctx).Model(&Project{}).Where("name = ? AND path <> ? AND id <> ?", composeName, dirPath, proj.ID).Count(&duplicates).Error; countErr != nil {
+ slog.WarnContext(ctx, "failed to check duplicate compose project names during project sync", "composeProjectName", composeName, "path", dirPath, "error", countErr)
+ } else if duplicates > 0 {
+ slog.WarnContext(ctx, "multiple project directories resolve to the same compose project name", "composeProjectName", composeName, "path", dirPath, "duplicates", duplicates)
+ }
+ }
+ return s.reconcileComposeTagsForProject(ctx, proj)
}
if err != nil {
return fmt.Errorf("query existing project for %q failed: %w", dirPath, err)
@@ -2869,7 +2620,7 @@ func (s *ProjectService) upsertProjectForDir(ctx context.Context, dirName, dirPa
}
}
if len(updates) == 0 {
- return s.reconcileComposeTagsForProjectInternal(ctx, &existing)
+ return s.reconcileComposeTagsForProject(ctx, &existing)
}
updates["updated_at"] = time.Now()
@@ -2879,154 +2630,51 @@ func (s *ProjectService) upsertProjectForDir(ctx context.Context, dirName, dirPa
Updates(updates).Error; uerr != nil {
return fmt.Errorf("update project %s failed: %w", existing.ID, uerr)
}
- if serviceCountErr == nil {
- s.warnDuplicateComposeNameForPathInternal(ctx, composeMetadata.ResolvedProjectName, dirPath, existing.ID)
- }
- return s.reconcileComposeTagsForProjectInternal(ctx, &existing)
-}
-
-func (s *ProjectService) warnDuplicateComposeNameForPathInternal(ctx context.Context, composeProjectName, dirPath, projectID string) {
- if strings.TrimSpace(composeProjectName) == "" {
- return
- }
-
- var count int64
- if err := s.db.WithContext(ctx).
- Model(&Project{}).
- Where("name = ? AND path <> ? AND id <> ?", composeProjectName, dirPath, projectID).
- Count(&count).Error; err != nil {
- slog.WarnContext(ctx, "failed to check duplicate compose project names during project sync", "composeProjectName", composeProjectName, "path", dirPath, "error", err)
- return
- }
- if count > 0 {
- slog.WarnContext(ctx, "multiple project directories resolve to the same compose project name", "composeProjectName", composeProjectName, "path", dirPath, "duplicates", count)
- }
-}
-
-func (s *ProjectService) cleanupDBProjectsInternal(ctx context.Context, seen map[string]struct{}, followProjectSymlinks bool, projectsDir string, maxDepth int) error {
- var all []Project
- if err := s.db.WithContext(ctx).Find(&all).Error; err != nil {
- return fmt.Errorf("list projects for cleanup failed: %w", err)
- }
-
- // Decide deletions without performing them. Collecting decisions up front lets
- // the mass-wipe guard veto an entire suspicious pass (e.g. the projects volume
- // is unmounted, so every path is missing at once) before any rows are removed.
- candidates := 0
- pendingDeletions := make([]projectCleanupDecision, 0)
- tempDeletions := make([]projectCleanupDecision, 0)
- for _, p := range all {
- if skipProjectCleanupInternal(p, seen) {
- continue
- }
- if isInternalScratchProjectInternal(p) {
- tempDeletions = append(tempDeletions, projectCleanupDecision{project: p, reason: "removed internal Arcane scratch record (project-update/gitops temp dir)"})
- continue
- }
- // Projects inside filesystem snapshot/trash directories (e.g. BTRFS
- // #snapshot) are point-in-time copies mistakenly registered by earlier
- // discovery passes. The decision is name-based, not missing-path-based,
- // so it bypasses the mass-wipe guard like the scratch records above.
- if rel := listing.RelativePath(projectsDir, p.Path); rel != "" && projects.PathContainsSnapshotDirectory(rel) {
- tempDeletions = append(tempDeletions, projectCleanupDecision{project: p, reason: "removed project inside a filesystem snapshot/trash directory"})
- continue
+ if composeName := composeMetadata.ResolvedProjectName; serviceCountErr == nil && strings.TrimSpace(composeName) != "" {
+ var duplicates int64
+ if countErr := s.db.WithContext(ctx).Model(&Project{}).Where("name = ? AND path <> ? AND id <> ?", composeName, dirPath, existing.ID).Count(&duplicates).Error; countErr != nil {
+ slog.WarnContext(ctx, "failed to check duplicate compose project names during project sync", "composeProjectName", composeName, "path", dirPath, "error", countErr)
+ } else if duplicates > 0 {
+ slog.WarnContext(ctx, "multiple project directories resolve to the same compose project name", "composeProjectName", composeName, "path", dirPath, "duplicates", duplicates)
}
- candidates++
- if decision, remove := s.evaluateProjectCleanupInternal(ctx, p, followProjectSymlinks, projectsDir, maxDepth).Get(); remove {
- pendingDeletions = append(pendingDeletions, decision)
- }
- }
-
- for _, decision := range tempDeletions {
- s.deleteProjectDuringCleanupInternal(ctx, decision.project, decision.reason)
}
-
- if projectsync.CleanupWouldMassWipe(ctx, candidates, len(pendingDeletions), projectsDir) {
- return nil
- }
-
- for _, decision := range pendingDeletions {
- s.deleteProjectDuringCleanupInternal(ctx, decision.project, decision.reason)
- }
- return nil
+ return s.reconcileComposeTagsForProject(ctx, &existing)
}
-// evaluateProjectCleanupInternal decides whether a project that was not seen in
-// the current filesystem pass should be pruned. It performs only read-only checks
-// (warning in place for the "keep" cases); the actual deletion is deferred to the
-// caller so the mass-wipe guard can veto an entire suspicious pass.
-func (s *ProjectService) evaluateProjectCleanupInternal(ctx context.Context, p Project, followProjectSymlinks bool, projectsDir string, maxDepth int) mo.Option[projectCleanupDecision] {
- if s.projectExceedsScanDepthInternal(p, projectsDir, maxDepth) {
+// evaluateProjectCleanup decides whether a project missing from the current
+// filesystem pass should be pruned. It only reads; the caller defers deletion
+// so the mass-wipe guard can veto the whole pass.
+func (s *ProjectService) evaluateProjectCleanup(ctx context.Context, p Project, followProjectSymlinks bool, projectsDir string, maxDepth int) mo.Option[projectCleanupDecision] {
+ // Projects still on disk but beyond a lowered scan depth are no longer
+ // discovered; root-level and outside paths fall through to the disk checks.
+ if rel := listing.RelativePath(projectsDir, p.Path); maxDepth > 0 && rel != "" && strings.Count(rel, "/") >= maxDepth {
return mo.Some(projectCleanupDecision{project: p, reason: "removed project: directory is beyond the configured scan depth"})
}
validDir, err := projects.IsProjectDirectoryPath(p.Path, followProjectSymlinks)
- if err != nil {
- return evaluateProjectPathErrorInternal(ctx, p, err)
- }
- if !validDir {
+ switch {
+ case os.IsNotExist(err):
+ return mo.Some(projectCleanupDecision{project: p, reason: "removed project: directory no longer exists"})
+ case err != nil:
+ slog.WarnContext(ctx, "stat error during cleanup; keeping DB record", "path", p.Path, "error", err)
+ return mo.None[projectCleanupDecision]()
+ case !validDir:
return mo.Some(projectCleanupDecision{project: p, reason: "removed project: path is no longer a valid project directory"})
}
- return s.evaluateProjectComposeFileInternal(ctx, p)
-}
-
-func (s *ProjectService) projectExceedsScanDepthInternal(p Project, projectsDir string, maxDepth int) bool {
- // Remove projects that still exist on disk but now fall outside the configured
- // scan depth (e.g. after PROJECT_SCAN_MAX_DEPTH was lowered). They are no
- // longer discovered, so they must not linger in the list. Projects at the
- // projects root or outside it (relativePath == "") are left to the on-disk
- // validation below.
- if maxDepth <= 0 {
- return false
- }
-
- rel := listing.RelativePath(projectsDir, p.Path)
- return rel != "" && strings.Count(rel, "/") >= maxDepth
-}
-
-func (s *ProjectService) evaluateProjectComposeFileInternal(ctx context.Context, p Project) mo.Option[projectCleanupDecision] {
- _, err := s.ResolveProjectComposeFile(ctx, &p)
- if err == nil {
+ // Only a directory with no compose file is pruned. An ambiguous match, an
+ // unreadable directory, or a parse error keeps a possibly deployable project.
+ _, err = s.ResolveProjectComposeFile(ctx, &p)
+ switch {
+ case err == nil:
return mo.None[projectCleanupDecision]()
- }
-
- // The project directory still exists here (it passed the directory-validity
- // check above). Only prune the DB record when the directory genuinely has no
- // compose file. Any other resolution failure — an ambiguous match ("multiple
- // custom compose files"), an unreadable directory, a transient parse error —
- // means the project still has compose content on disk and may be deployable.
- // Deleting it would silently destroy a live project whose files are intact, so
- // keep the record and warn instead.
- if !errors.Is(err, common.ErrComposeFileNotFound) {
- slog.WarnContext(ctx, "project directory present but compose file unresolved during cleanup; keeping DB record",
- "projectId", p.ID, "path", p.Path, "error", err)
+ case !errors.Is(err, common.ErrComposeFileNotFound):
+ slog.WarnContext(ctx, "project directory present but compose file unresolved during cleanup; keeping DB record", "projectId", p.ID, "path", p.Path, "error", err)
return mo.None[projectCleanupDecision]()
}
-
return mo.Some(projectCleanupDecision{project: p, reason: "removed orphaned project: directory present but contains no compose file"})
}
-// deleteProjectDuringCleanupInternal removes a project record discovered to be
-// stale during the filesystem reconcile. Every removal is logged (WARN on
-// success, ERROR on failure) so this destructive operation always leaves an
-// audit trail — previously successful deletions were silent.
-func (s *ProjectService) deleteProjectDuringCleanupInternal(ctx context.Context, p Project, reason string, attrs ...any) {
- logAttrs := make([]any, 0, 6+len(attrs))
- logAttrs = append(logAttrs, "projectID", p.ID, "name", p.Name, "path", p.Path)
- logAttrs = append(logAttrs, attrs...)
-
- if derr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- return deleteProjectWithTagsInternal(tx, p.ID)
- }); derr != nil {
- slog.ErrorContext(ctx, "failed to delete project during filesystem cleanup",
- append(logAttrs, "reason", reason, "error", derr)...)
- return
- }
-
- slog.WarnContext(ctx, "deleted project during filesystem cleanup", append(logAttrs, "reason", reason)...)
-}
-
// ApplyGitSyncEnvToDirectory applies the same managed three-file environment
// merge used by single-file project syncs and returns the effective content
// before and after the update.
@@ -3034,7 +2682,7 @@ func (s *ProjectService) ApplyGitSyncEnvToDirectory(ctx context.Context, project
return projectsync.ApplyGitSyncEnv(ctx, projectPath, projectsDirectory, gitEnvContent)
}
-func (s *ProjectService) reconcileComposeTagsForProjectInternal(ctx context.Context, projectModel *Project) error {
+func (s *ProjectService) reconcileComposeTagsForProject(ctx context.Context, projectModel *Project) error {
if projectModel == nil {
return nil
}
@@ -3053,7 +2701,7 @@ func (s *ProjectService) reconcileComposeTagsForProjectInternal(ctx context.Cont
if !meta.ProjectTagsAuthoritative {
return nil
}
- return s.reconcileComposeProjectTagsInternal(ctx, projectModel.ID, meta.ProjectTags)
+ return s.reconcileComposeProjectTags(ctx, projectModel.ID, meta.ProjectTags)
}
func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, name, composeContent, envContent, overrideContent *string, user usertypes.Actor) (*Project, error) {
@@ -3062,20 +2710,22 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return nil, err
}
- name = resolveAuthoritativeProjectNameInternal(ctx, &proj, name, composeContent)
- renameRequested := isProjectRenameRequestedInternal(&proj, name)
- if recoverProjectRenameJournalForProjectErr := s.updates.RecoverProject(ctx, projectID); recoverProjectRenameJournalForProjectErr != nil {
- if renameRequested {
- return nil, recoverProjectRenameJournalForProjectErr
+ name = resolveAuthoritativeProjectName(ctx, &proj, name, composeContent)
+ newName := strings.TrimSpace(mo.PointerToOption(name).OrEmpty())
+ if recoverErr := s.updates.RecoverProject(ctx, projectID); recoverErr != nil {
+ if newName != "" && proj.Name != newName {
+ return nil, recoverErr
}
- slog.WarnContext(ctx, "project rename journal recovery failed before non-rename update; continuing", "projectId", projectID, "error", recoverProjectRenameJournalForProjectErr)
+ slog.WarnContext(ctx, "project rename journal recovery failed before non-rename update; continuing", "projectId", projectID, "error", recoverErr)
} else {
- proj, projectsDirectory, recoverProjectRenameJournalForProjectErr = s.getProjectForUpdate(ctx, projectID)
- if recoverProjectRenameJournalForProjectErr != nil {
- return nil, recoverProjectRenameJournalForProjectErr
+ proj, projectsDirectory, recoverErr = s.getProjectForUpdate(ctx, projectID)
+ if recoverErr != nil {
+ return nil, recoverErr
}
- name = resolveAuthoritativeProjectNameInternal(ctx, &proj, name, composeContent)
+ name = resolveAuthoritativeProjectName(ctx, &proj, name, composeContent)
+ newName = strings.TrimSpace(mo.PointerToOption(name).OrEmpty())
}
+ renameRequested := newName != "" && proj.Name != newName
if proj.IsArchived {
return nil, common.Classify(common.ErrProjectArchived, errors.New("project is archived and must be unarchived before this action"))
@@ -3083,22 +2733,41 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
if ensureProjectEnvReadableErr := update.EnsureProjectEnvReadable(ctx, projectsDirectory, proj.Path); ensureProjectEnvReadableErr != nil {
return nil, ensureProjectEnvReadableErr
}
- if ensureProjectStoppedForRenameErr := s.ensureProjectStoppedForRenameInternal(ctx, &proj, name); ensureProjectStoppedForRenameErr != nil {
- return nil, ensureProjectStoppedForRenameErr
- }
- volumeMigration, err := s.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, &proj, name, projectsDirectory, composeContent, envContent, overrideContent)
- if err != nil {
- return nil, err
+ // A rename requires the stored and the live status to both be stopped.
+ var volumeMigration volume.Migration
+ if renameRequested {
+ if proj.Status != ProjectStatusStopped && proj.Status != ProjectStatusUnknown {
+ return nil, fmt.Errorf("project must be stopped before renaming (current status: %s)", proj.Status)
+ }
+ services, servicesErr := s.projectServices(ctx, proj.ID)
+ if servicesErr != nil {
+ slog.WarnContext(ctx, "failed to resolve project status before rename", "projectId", proj.ID, "error", servicesErr)
+ return nil, fmt.Errorf("project must be stopped before renaming (current status: %s): failed to verify live status: %w", proj.Status, servicesErr)
+ }
+ if status := ProjectStatus(listing.ProjectStatus(services)); status != ProjectStatusStopped {
+ return nil, fmt.Errorf("project must be stopped before renaming (current status: %s)", status)
+ }
+ proj.Status, proj.StatusReason = ProjectStatusStopped, nil
+ proj.ServiceCount, proj.RunningCount = listing.ServiceCounts(services)
+
+ if volumeMigration, err = s.prepareProjectRenameVolumeMigration(ctx, &proj, newName, projectsDirectory, composeContent, envContent, overrideContent); err != nil {
+ return nil, err
+ }
}
renameJournal := s.updates.Prepare(proj.ID, proj.Name, proj.Path, proj.DirName, name, projectsDirectory, volumeMigration)
- backup, cleanupBackup, err := s.prepareProjectUpdateBackupInternal(ctx, projectsDirectory, proj.Path, composeContent, envContent, overrideContent)
- if err != nil {
- return nil, err
+ contentChanged := composeContent != nil || envContent != nil || overrideContent != nil
+ var backup *projects.ProjectUpdateBackup
+ if contentChanged {
+ var cleanupBackup func()
+ backup, cleanupBackup, err = projects.BackupProjectDirectory(ctx, projectsDirectory, proj.Path, ".project-update-backup-*", projects.ProjectUpdateBackupScope{TopLevelFiles: true})
+ if err != nil {
+ return nil, err
+ }
+ defer cleanupBackup()
}
- defer cleanupBackup()
journalActive := renameJournal != nil
if journalActive {
@@ -3108,28 +2777,31 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
}
projectStateCommitted := false
- if withProjectRenameRollbackErr := withProjectRenameRollbackInternal(ctx, &proj, &projectStateCommitted, func() error {
- return s.applyProjectUpdateWithRenameJournalInternal(
- ctx,
- &proj,
- name,
- projectsDirectory,
- composeContent,
- envContent,
- overrideContent,
- volumeMigration,
- renameJournal,
- &journalActive,
- &projectStateCommitted,
+ if updateErr := withProjectRenameRollback(ctx, &proj, &projectStateCommitted, func() error {
+ return s.applyProjectUpdate(
+ ctx, &proj, renameRequested, newName, projectsDirectory,
+ composeContent, envContent, overrideContent,
+ volumeMigration, renameJournal, &journalActive, &projectStateCommitted,
)
- }); withProjectRenameRollbackErr != nil {
- withProjectRenameRollbackErr = s.handleProjectUpdateFailureInternal(ctx, projectID, projectsDirectory, &proj, backup, &journalActive, projectStateCommitted, withProjectRenameRollbackErr)
- return nil, withProjectRenameRollbackErr
+ }); updateErr != nil {
+ return nil, s.handleProjectUpdateFailure(ctx, projectID, projectsDirectory, &proj, backup, &journalActive, projectStateCommitted, updateErr)
}
- s.refreshProjectAfterContentUpdateInternal(ctx, &proj, composeContent, overrideContent)
- s.logProjectUpdateEventInternal(ctx, &proj, composeContent, envContent, overrideContent, user)
- if composeContent != nil || envContent != nil || overrideContent != nil {
+ if composeContent != nil || overrideContent != nil {
+ s.refreshProjectAfterContentUpdate(ctx, &proj)
+ }
+ metadata := database.JSON{"action": "update", "projectID": proj.ID, "projectName": proj.Name}
+ if composeContent != nil {
+ metadata["composeUpdated"] = true
+ }
+ if envContent != nil {
+ metadata["envUpdated"] = true
+ }
+ if overrideContent != nil {
+ metadata["overrideUpdated"] = true
+ }
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, metadata, "could not log project update action")
+ if contentChanged {
s.FilesChanged.Publish(proj.ID)
}
@@ -3137,55 +2809,31 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return &proj, nil
}
-func (
- s *ProjectService,
-) prepareProjectUpdateBackupInternal(
- ctx context.Context,
- projectsDirectory, projectPath string,
- composeContent, envContent, overrideContent *string,
-) (
- *projects.ProjectUpdateBackup,
- func(),
- error,
-) {
- if composeContent == nil && envContent == nil && overrideContent == nil {
- return nil, func() {}, nil
- }
-
- scope := projects.ProjectUpdateBackupScope{TopLevelFiles: true}
- if scope.IsEmpty() {
- return nil, func() {}, nil
- }
-
- return projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)
-}
-
-func (
- s *ProjectService,
-) applyProjectUpdateWithRenameJournalInternal(
+// applyProjectUpdate renames, persists files, migrates volumes, and
+// saves the row; a failure before the save rolls an applied volume migration back.
+func (s *ProjectService) applyProjectUpdate(
ctx context.Context,
proj *Project,
- name *string,
- projectsDirectory string,
+ renameRequested bool,
+ newName, projectsDirectory string,
composeContent, envContent, overrideContent *string,
volumeMigration volume.Migration,
renameJournal *projecttypes.RenameJournal,
journalActive, projectStateCommitted *bool,
-) (
- err error,
-) {
+) (err error) {
volumeMigrationApplied := false
defer func() {
- stateCommitted := projectStateCommitted != nil && *projectStateCommitted
- if err != nil && volumeMigrationApplied && !stateCommitted {
+ if err != nil && volumeMigrationApplied && !*projectStateCommitted {
if rollbackErr := volumeMigration.Rollback(ctx); rollbackErr != nil {
err = errors.Join(err, fmt.Errorf("failed to rollback project volume rename: %w", rollbackErr))
}
}
}()
- if renameErr := s.applyProjectRenameIfNeeded(ctx, proj, name, projectsDirectory); renameErr != nil {
- return renameErr
+ if renameRequested {
+ if renameErr := s.applyProjectRename(ctx, proj, newName, projectsDirectory); renameErr != nil {
+ return renameErr
+ }
}
if persistFilesErr := s.persistUpdatedProjectFiles(ctx, proj, projectsDirectory, composeContent, envContent, overrideContent); persistFilesErr != nil {
return persistFilesErr
@@ -3193,42 +2841,17 @@ func (
if migrationErr := projects.ApplyRenameVolumeMigration(ctx, s.updates.Operations(), volumeMigration, renameJournal, &volumeMigrationApplied); migrationErr != nil {
return migrationErr
}
- if saveProjectErr := s.saveProjectUpdateInternal(ctx, proj); saveProjectErr != nil {
- return saveProjectErr
- }
- if projectStateCommitted != nil {
- *projectStateCommitted = true
+ if saveErr := s.db.WithContext(ctx).Save(proj).Error; saveErr != nil {
+ return fmt.Errorf("failed to update project: %w", saveErr)
}
+ *projectStateCommitted = true
projects.FinalizeRenameAfterCommit(ctx, s.updates.Operations(), proj.ID, volumeMigration, renameJournal, journalActive)
return nil
}
-func (s *ProjectService) saveProjectUpdateInternal(ctx context.Context, proj *Project) error {
- tx := s.db.WithContext(ctx).Begin()
- if tx.Error != nil {
- return fmt.Errorf("failed to start project update transaction: %w", tx.Error)
- }
-
- txCommitted := false
- defer func() {
- if !txCommitted {
- _ = tx.Rollback().Error
- }
- }()
-
- if err := tx.Save(proj).Error; err != nil {
- return fmt.Errorf("failed to update project: %w", err)
- }
- if err := tx.Commit().Error; err != nil {
- return fmt.Errorf("failed to commit project update: %w", err)
- }
- txCommitted = true
- return nil
-}
-
-func (
- s *ProjectService,
-) handleProjectUpdateFailureInternal(
+// handleProjectUpdateFailure restores the pre-update files and replays
+// an active rename journal unless the project row was already committed.
+func (s *ProjectService) handleProjectUpdateFailure(
ctx context.Context,
projectID, projectsDirectory string,
proj *Project,
@@ -3256,52 +2879,26 @@ func (
return err
}
-func (s *ProjectService) logProjectUpdateEventInternal(ctx context.Context, proj *Project, composeContent, envContent, overrideContent *string, user usertypes.Actor) {
- metadata := database.JSON{
- "action": "update",
- "projectID": proj.ID,
- "projectName": proj.Name,
- }
- if composeContent != nil {
- metadata["composeUpdated"] = true
- }
- if envContent != nil {
- metadata["envUpdated"] = true
- }
- if overrideContent != nil {
- metadata["overrideUpdated"] = true
- }
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, metadata, "could not log project update action")
-}
-
-func (s *ProjectService) refreshProjectAfterContentUpdateInternal(ctx context.Context, proj *Project, composeContent, overrideContent *string) {
- if composeContent == nil && overrideContent == nil {
- return
- }
-
- s.refreshComposeProjectNameInternal(ctx, proj)
- s.refreshProjectImageRefsInternal(ctx, proj)
- if err := s.reconcileComposeTagsForProjectInternal(ctx, proj); err != nil {
- slog.WarnContext(ctx, "failed to reconcile Compose project tags after project update", "projectId", proj.ID, "error", err)
+// refreshProjectAfterContentUpdate re-derives the compose name, image
+// refs, Compose tags, and service counts after a compose or override write.
+func (s *ProjectService) refreshProjectAfterContentUpdate(ctx context.Context, proj *Project) {
+ s.refreshComposeProjectName(ctx, proj)
+ s.refreshProjectImageRefs(ctx, proj)
+ if err := s.reconcileComposeTagsForProject(ctx, proj); err != nil {
+ slog.WarnContext(ctx, "failed to reconcile Compose project tags after project content update", "projectId", proj.ID, "error", err)
}
- if err := s.updateProjectStatusandCountsInternal(ctx, proj.ID, proj.Status); err != nil {
- slog.WarnContext(ctx, "failed to update service counts after compose edit", "projectId", proj.ID, "error", err)
+ if err := s.updateProjectStatusAndCounts(ctx, proj.ID, proj.Status); err != nil {
+ slog.WarnContext(ctx, "failed to update service counts after project content update", "projectId", proj.ID, "error", err)
}
}
-func (
- s *ProjectService,
-) ApplyGitSyncProjectFiles(
+func (s *ProjectService) ApplyGitSyncProjectFiles(
ctx context.Context,
projectID, composeContent string,
gitEnvContent, gitOverrideContent *string,
gitOverrideFileName string,
user usertypes.Actor,
-) (
- *Project,
- bool,
- error,
-) {
+) (*Project, bool, error) {
proj, projectsDirectory, err := s.getProjectForUpdate(ctx, projectID)
if err != nil {
return nil, false, err
@@ -3309,7 +2906,7 @@ func (
if proj.IsArchived {
return nil, false, common.Classify(common.ErrProjectArchived, errors.New("project is archived and must be unarchived before this action"))
}
- before := s.readGitSyncProjectContentInternal(ctx, proj.ID)
+ beforeCompose, beforeEnv, beforeOverride, beforeErr := s.projectContent(ctx, proj.ID)
envUpdate, err := projectsync.PrepareGitSyncEnvUpdate(proj.Path, gitEnvContent)
if err != nil {
@@ -3322,7 +2919,7 @@ func (
proj.Path,
proj.Name,
composeContent,
- envUpdate.EffectiveContent(),
+ envUpdate.EffectiveContent,
gitOverrideContent,
gitOverrideFileName,
true,
@@ -3330,116 +2927,59 @@ func (
return nil, false, fmt.Errorf("invalid compose file: %w", validateComposeContentForUpdateErr)
}
- backup, cleanupBackup, err := s.prepareProjectUpdateBackupInternal(ctx, projectsDirectory, proj.Path, &composeContent, gitEnvContent, gitOverrideContent)
+ backup, cleanupBackup, err := projects.BackupProjectDirectory(ctx, projectsDirectory, proj.Path, ".project-update-backup-*", projects.ProjectUpdateBackupScope{TopLevelFiles: true})
if err != nil {
return nil, false, err
}
defer cleanupBackup()
- journalActive := false
- projectStateCommitted := false
- if applyGitSyncProjectFilesErr := s.applyGitSyncProjectFilesInternal(
- ctx,
- &proj,
- projectsDirectory,
- composeContent,
- envUpdate,
- gitOverrideContent,
- gitOverrideFileName,
- &projectStateCommitted,
- ); applyGitSyncProjectFilesErr != nil {
- // A failure after the env persist would otherwise leave the project with
- // new env values and an old or partially updated compose file set.
- applyGitSyncProjectFilesErr = s.handleProjectUpdateFailureInternal(ctx, projectID, projectsDirectory, &proj, backup, &journalActive, projectStateCommitted, applyGitSyncProjectFilesErr)
- return nil, false, applyGitSyncProjectFilesErr
- }
-
- s.refreshComposeProjectNameInternal(ctx, &proj)
- s.refreshProjectImageRefsInternal(ctx, &proj)
- if reconcileComposeTagsForProjectErr := s.reconcileComposeTagsForProjectInternal(ctx, &proj); reconcileComposeTagsForProjectErr != nil {
- slog.WarnContext(ctx, "failed to reconcile Compose project tags after git sync", "projectId", proj.ID, "error", reconcileComposeTagsForProjectErr)
- }
-
- // Recalculate service counts and status after compose file sync
- if updateProjectStatusandCountsErr := s.updateProjectStatusandCountsInternal(ctx, proj.ID, proj.Status); updateProjectStatusandCountsErr != nil {
- slog.WarnContext(ctx, "failed to update service counts after git sync", "projectId", proj.ID, "error", updateProjectStatusandCountsErr)
- }
-
- after := s.readGitSyncProjectContentInternal(ctx, proj.ID)
- envSourceRemoved := gitEnvContent == nil && envUpdate.HadGitSource()
- changed := s.logGitSyncProjectUpdateInternal(ctx, &proj, before, after, envSourceRemoved, user)
-
- return &proj, changed, nil
-}
-
-func (s *ProjectService) readGitSyncProjectContentInternal(ctx context.Context, projectID string) gitSyncProjectContentInternal {
- compose, env, override, err := s.GetProjectContent(ctx, projectID)
- if err != nil {
- slog.WarnContext(ctx, "failed to read project content for git sync change detection; treating as changed", "projectId", projectID, "error", err)
- return gitSyncProjectContentInternal{unreadable: true}
- }
- return gitSyncProjectContentInternal{compose: compose, env: env, override: override}
-}
-
-// logGitSyncProjectUpdateInternal logs project.update when the effective content
-// changed or the Git env source was removed, and reports whether content changed.
-func (s *ProjectService) logGitSyncProjectUpdateInternal(ctx context.Context, proj *Project, before, after gitSyncProjectContentInternal, envSourceRemoved bool, user usertypes.Actor) bool {
- unreadable := before.unreadable || after.unreadable
- composeChanged := unreadable || before.compose != after.compose
- envChanged := unreadable || projects.EnvContentChanged(before.env, after.env)
- overrideChanged := unreadable || before.override != after.override
+ // The env is persisted first so WriteComposeFile targets the COMPOSE_FILE base
+ // the updated .env selects. A failure before the row save restores the backup,
+ // so new env values never pair with an old or partial compose file set.
+ var applyErr error
+ if envErr := projectsync.PersistGitSyncEnvFiles(ctx, proj.Path, projectsDirectory, envUpdate); envErr != nil {
+ applyErr = fmt.Errorf("failed to sync git env files: %w", envErr)
+ } else if composeErr := projects.WriteComposeFile(ctx, projectsDirectory, proj.Path, composeContent); composeErr != nil {
+ applyErr = fmt.Errorf("failed to save compose file: %w", composeErr)
+ } else if overrideErr := projects.WriteComposeOverrideFile(ctx, projectsDirectory, proj.Path, gitOverrideContent, gitOverrideFileName); overrideErr != nil {
+ applyErr = fmt.Errorf("failed to sync git override file: %w", overrideErr)
+ } else if saveErr := s.db.WithContext(ctx).Save(&proj).Error; saveErr != nil {
+ applyErr = fmt.Errorf("failed to update project: %w", saveErr)
+ }
+ if applyErr != nil {
+ journalActive := false
+ return nil, false, s.handleProjectUpdateFailure(ctx, projectID, projectsDirectory, &proj, backup, &journalActive, false, applyErr)
+ }
+
+ s.refreshProjectAfterContentUpdate(ctx, &proj)
+
+ // Unreadable content on either side always compares as changed.
+ afterCompose, afterEnv, afterOverride, afterErr := s.projectContent(ctx, proj.ID)
+ unreadable := beforeErr != nil || afterErr != nil
+ if unreadable {
+ slog.WarnContext(ctx, "failed to read project content for git sync change detection; treating as changed", "projectId", proj.ID, "error", errors.Join(beforeErr, afterErr))
+ }
+ composeChanged := unreadable || beforeCompose != afterCompose
+ envChanged := unreadable || projects.EnvContentChanged(beforeEnv, afterEnv)
+ overrideChanged := unreadable || beforeOverride != afterOverride
contentChanged := composeChanged || envChanged || overrideChanged
- if !contentChanged && !envSourceRemoved {
- return false
+ envSourceRemoved := gitEnvContent == nil && envUpdate.State.HasGitSource
+ if contentChanged || envSourceRemoved {
+ metadata := database.JSON{
+ "action": "git_sync_update",
+ "projectID": proj.ID,
+ "projectName": proj.Name,
+ "composeUpdated": composeChanged,
+ "envUpdated": envChanged,
+ "overrideUpdated": overrideChanged,
+ }
+ if envSourceRemoved {
+ metadata["envSourceRemoved"] = true
+ }
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, metadata, "could not log git sync project update action")
}
- metadata := database.JSON{
- "action": "git_sync_update",
- "projectID": proj.ID,
- "projectName": proj.Name,
- "composeUpdated": composeChanged,
- "envUpdated": envChanged,
- "overrideUpdated": overrideChanged,
- }
- if envSourceRemoved {
- metadata["envSourceRemoved"] = true
- }
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, metadata, "could not log git sync project update action")
- return contentChanged
-}
-
-// applyGitSyncProjectFilesInternal persists the synced env, compose, and
-// override files, then the project row. The env is persisted first so
-// WriteComposeFile targets the COMPOSE_FILE base the updated .env selects, not
-// the one the old .env selected. When it fails before the project row is saved,
-// the caller restores the pre-update backup.
-func (
- s *ProjectService,
-) applyGitSyncProjectFilesInternal(
- ctx context.Context,
- proj *Project,
- projectsDirectory, composeContent string,
- envUpdate projectsync.GitSyncEnvUpdate,
- gitOverrideContent *string,
- gitOverrideFileName string,
- projectStateCommitted *bool,
-) error {
- if err := projectsync.PersistGitSyncEnvFiles(ctx, proj.Path, projectsDirectory, envUpdate); err != nil {
- return fmt.Errorf("failed to sync git env files: %w", err)
- }
- if err := projects.WriteComposeFile(ctx, projectsDirectory, proj.Path, composeContent); err != nil {
- return fmt.Errorf("failed to save compose file: %w", err)
- }
- if err := projects.WriteComposeOverrideFile(ctx, projectsDirectory, proj.Path, gitOverrideContent, gitOverrideFileName); err != nil {
- return fmt.Errorf("failed to sync git override file: %w", err)
- }
- if err := s.db.WithContext(ctx).Save(proj).Error; err != nil {
- return fmt.Errorf("failed to update project: %w", err)
- }
- if projectStateCommitted != nil {
- *projectStateCommitted = true
- }
- return nil
+ return &proj, contentChanged, nil
}
func (s *ProjectService) getProjectForUpdate(ctx context.Context, projectID string) (Project, string, error) {
@@ -3451,7 +2991,7 @@ func (s *ProjectService) getProjectForUpdate(ctx context.Context, projectID stri
return Project{}, "", fmt.Errorf("failed to get project: %w", err)
}
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects"))
+ projectsDirectory, err := s.GetProjectsDirectory(ctx)
if err != nil {
return Project{}, "", fmt.Errorf("failed to get projects directory: %w", err)
}
@@ -3463,61 +3003,48 @@ func (s *ProjectService) getProjectForUpdate(ctx context.Context, projectID stri
return proj, projectsDirectory, nil
}
-func (
- s *ProjectService,
-) prepareProjectRenameVolumeMigrationForUpdateInternal(
+// prepareProjectRenameVolumeMigration plans the volume rename for a
+// stopped project. Content changes are applied to a scratch preview first so
+// the plan reflects the updated compose files.
+func (s *ProjectService) prepareProjectRenameVolumeMigration(
ctx context.Context,
proj *Project,
- name *string,
- projectsDirectory string,
+ newName, projectsDirectory string,
composeContent, envContent, overrideContent *string,
-) (
- volume.Migration,
- error,
-) {
- if !isProjectRenameRequestedInternal(proj, name) {
- return nil, nil
- }
-
- if composeContent == nil && envContent == nil && overrideContent == nil {
- return s.prepareProjectRenameVolumeMigrationInternal(ctx, proj, name)
- }
+) (volume.Migration, error) {
+ target := proj
+ if composeContent != nil || envContent != nil || overrideContent != nil {
+ previewLogical, err := acfs.MkdirTemp(ctx, projectsDirectory, "/", ".project-update-preview-*")
+ if err != nil {
+ return nil, fmt.Errorf("failed to create project update preview: %w", err)
+ }
+ previewPath := filepath.Join(projectsDirectory, filepath.FromSlash(strings.TrimPrefix(previewLogical, "/")))
+ defer func() {
+ // acfs refuses an already-cancelled context, so cleanup runs detached
+ // or a cancelled update leaks the preview directory.
+ cleanupCtx := context.WithoutCancel(ctx)
+ if removeErr := acfs.RemoveAll(cleanupCtx, projectsDirectory, previewLogical); removeErr != nil {
+ slog.WarnContext(cleanupCtx, "failed to remove project update preview", "path", previewPath, "error", removeErr)
+ }
+ }()
- previewLogical, err := acfs.MkdirTemp(ctx, projectsDirectory, "/", ".project-update-preview-*")
- if err != nil {
- return nil, fmt.Errorf("failed to create project update preview: %w", err)
- }
- previewPath := filepath.Join(projectsDirectory, filepath.FromSlash(strings.TrimPrefix(previewLogical, "/")))
- defer func() {
- // The cleanup must run even when the update was cancelled, or the
- // preview directory leaks: acfs refuses operations on an
- // already-cancelled context.
- cleanupCtx := context.WithoutCancel(ctx)
- if removeErr := acfs.RemoveAll(cleanupCtx, projectsDirectory, previewLogical); removeErr != nil {
- slog.WarnContext(cleanupCtx, "failed to remove project update preview", "path", previewPath, "error", removeErr)
+ if _, copyDirErr := acfs.CopyDir(ctx, proj.Path, previewPath, acfstypes.CopyOptions{}); copyDirErr != nil {
+ return nil, fmt.Errorf("failed to prepare project update preview: %w", copyDirErr)
}
- }()
-
- if _, copyDirErr := acfs.CopyDir(ctx, proj.Path, previewPath, acfstypes.CopyOptions{}); copyDirErr != nil {
- return nil, fmt.Errorf("failed to prepare project update preview: %w", copyDirErr)
- }
-
- previewProject := *proj
- previewProject.Path = previewPath
- if persistUpdatedProjectFilesErr := s.persistUpdatedProjectFiles(ctx, &previewProject, projectsDirectory, composeContent, envContent, overrideContent); persistUpdatedProjectFilesErr != nil {
- return nil, fmt.Errorf("failed to prepare project update preview: %w", persistUpdatedProjectFilesErr)
+ previewProject := *proj
+ previewProject.Path = previewPath
+ if persistErr := s.persistUpdatedProjectFiles(ctx, &previewProject, projectsDirectory, composeContent, envContent, overrideContent); persistErr != nil {
+ return nil, fmt.Errorf("failed to prepare project update preview: %w", persistErr)
+ }
+ target = &previewProject
}
- return s.prepareProjectRenameVolumeMigrationInternal(ctx, &previewProject, name)
-}
-
-func (s *ProjectService) prepareProjectRenameVolumeMigrationInternal(ctx context.Context, proj *Project, name *string) (volume.Migration, error) {
- oldComposeName, newComposeName, ok := projectRenameVolumeMigrationComposeNamesInternal(s, proj, name)
- if !ok {
+ oldComposeName, newComposeName := projects.NormalizeProjectName(target.Name), projects.NormalizeProjectName(newName)
+ if s.dockerService == nil || target.Status != ProjectStatusStopped || oldComposeName == "" || newComposeName == "" || oldComposeName == newComposeName {
return nil, nil
}
- composeProject, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
+ composeProject, _, err := s.loadComposeProjectForProject(ctx, target, nil)
if err != nil {
if errors.Is(err, common.ErrProjectComposeFileNotFound) {
return nil, nil
@@ -3538,133 +3065,62 @@ func (s *ProjectService) prepareProjectRenameVolumeMigrationInternal(ctx context
return projects.PlanVolumeMigration(ctx, dockerClient, composeProject, oldComposeName, newComposeName, volumehelper.ToolsImage(toolsRegistry))
}
+// persistUpdatedProjectFiles validates and writes submitted compose, override,
+// and env content. An override-only save validates the on-disk base merged with
+// the requested override, so a base only valid with its override still passes
+// and a delete that would break the base fails before touching disk.
func (s *ProjectService) persistUpdatedProjectFiles(ctx context.Context, proj *Project, projectsDirectory string, composeContent, envContent, overrideContent *string) error {
- switch {
- case composeContent != nil:
- effectiveEnvContent, err := projectsync.EffectiveEnvContentForUpdate(proj.Path, envContent)
- if err != nil {
- return fmt.Errorf("invalid compose file: %w", err)
- }
- valOverride, valOverrideName := projects.ResolveEffectiveOverrideForValidation(proj.Path, overrideContent)
- if validateComposeContentForUpdateErr := projects.ValidateComposeContentForUpdate(
- ctx,
- projectsDirectory,
- proj.Path,
- proj.Name,
- *composeContent,
- effectiveEnvContent,
- valOverride,
- valOverrideName,
- false,
- ); validateComposeContentForUpdateErr != nil {
- return fmt.Errorf("invalid compose file: %w", validateComposeContentForUpdateErr)
- }
- // The env is persisted first so WriteComposeFile targets the COMPOSE_FILE
- // base the updated .env selects, not the one the old .env selected. A
- // non-nil composeContent is an explicit submission and is always written;
- // clients omit it when the compose editor is unchanged.
+ if composeContent == nil && overrideContent == nil {
if envContent != nil {
- if persistEffectiveEnvContentErr := projectsync.PersistEffectiveEnvContent(ctx, proj.Path, projectsDirectory, *envContent); persistEffectiveEnvContentErr != nil {
- return fmt.Errorf("failed to save project files: %w", persistEffectiveEnvContentErr)
- }
- } else if ensureEffectiveEnvFileErr := projectsync.EnsureEffectiveEnvFile(ctx, proj.Path, projectsDirectory); ensureEffectiveEnvFileErr != nil {
- return fmt.Errorf("failed to save project files: %w", ensureEffectiveEnvFileErr)
- }
- if writeComposeFileErr := projects.WriteComposeFile(ctx, projectsDirectory, proj.Path, *composeContent); writeComposeFileErr != nil {
- return fmt.Errorf("failed to save project files: %w", writeComposeFileErr)
- }
- if applyOverrideFileChangeErr := projects.ApplyOverrideFileChange(ctx, projectsDirectory, proj.Path, overrideContent); applyOverrideFileChangeErr != nil {
- return fmt.Errorf("failed to save project files: %w", applyOverrideFileChangeErr)
- }
- case overrideContent != nil:
- if err := s.persistOverrideOnlyUpdateInternal(ctx, proj, projectsDirectory, envContent, overrideContent); err != nil {
- return err
- }
- case envContent != nil:
- if err := projectsync.PersistEffectiveEnvContent(ctx, proj.Path, projectsDirectory, *envContent); err != nil {
- return err
+ return projectsync.PersistEffectiveEnvContent(ctx, proj.Path, projectsDirectory, *envContent)
}
+ return nil
}
- return nil
-}
-
-// persistOverrideOnlyUpdateInternal handles a save that changes the override (and
-// optionally the env) without touching the base compose file. It validates the
-// on-disk base merged with the requested override so a base that is only valid
-// *with* its override still validates, and a delete that would break the base
-// fails before touching disk.
-func (s *ProjectService) persistOverrideOnlyUpdateInternal(ctx context.Context, proj *Project, projectsDirectory string, envContent, overrideContent *string) error {
- baseContent, _, err := projects.ReadProjectFiles(ctx, proj.Path, "")
- if err != nil {
- return fmt.Errorf("failed to read project files: %w", err)
+ var baseContent string
+ if composeContent != nil {
+ baseContent = *composeContent
+ } else {
+ var err error
+ if baseContent, _, err = projects.ReadProjectFiles(ctx, proj.Path, ""); err != nil {
+ return fmt.Errorf("failed to read project files: %w", err)
+ }
}
effectiveEnvContent, err := projectsync.EffectiveEnvContentForUpdate(proj.Path, envContent)
if err != nil {
return fmt.Errorf("invalid compose file: %w", err)
}
valOverride, valOverrideName := projects.ResolveEffectiveOverrideForValidation(proj.Path, overrideContent)
- if validateComposeContentForUpdateErr := projects.ValidateComposeContentForUpdate(
- ctx,
- projectsDirectory,
- proj.Path,
- proj.Name,
- baseContent,
- effectiveEnvContent,
- valOverride,
- valOverrideName,
- false,
- ); validateComposeContentForUpdateErr != nil {
- return fmt.Errorf("invalid compose file: %w", validateComposeContentForUpdateErr)
+ if validateErr := projects.ValidateComposeContentForUpdate(ctx, projectsDirectory, proj.Path, proj.Name, baseContent, effectiveEnvContent, valOverride, valOverrideName, false); validateErr != nil {
+ return fmt.Errorf("invalid compose file: %w", validateErr)
}
+
+ // The env is persisted first so WriteComposeFile targets the COMPOSE_FILE
+ // base the updated .env selects. A non-nil composeContent is an explicit
+ // submission and is always written.
if envContent != nil {
- if persistEffectiveEnvContentErr := projectsync.PersistEffectiveEnvContent(ctx, proj.Path, projectsDirectory, *envContent); persistEffectiveEnvContentErr != nil {
- return fmt.Errorf("failed to save project files: %w", persistEffectiveEnvContentErr)
+ if persistErr := projectsync.PersistEffectiveEnvContent(ctx, proj.Path, projectsDirectory, *envContent); persistErr != nil {
+ return fmt.Errorf("failed to save project files: %w", persistErr)
+ }
+ } else if composeContent != nil {
+ if ensureErr := projectsync.EnsureEffectiveEnvFile(ctx, proj.Path, projectsDirectory); ensureErr != nil {
+ return fmt.Errorf("failed to save project files: %w", ensureErr)
}
}
- if applyOverrideFileChangeErr := projects.ApplyOverrideFileChange(ctx, projectsDirectory, proj.Path, overrideContent); applyOverrideFileChangeErr != nil {
- return fmt.Errorf("failed to save project files: %w", applyOverrideFileChangeErr)
- }
- return nil
-}
-
-func (s *ProjectService) ensureProjectStoppedForRenameInternal(ctx context.Context, proj *Project, name *string) error {
- if !isProjectRenameRequestedInternal(proj, name) {
- return nil
- }
- if proj.Status != ProjectStatusStopped && proj.Status != ProjectStatusUnknown {
- return fmt.Errorf("project must be stopped before renaming (current status: %s)", proj.Status)
- }
-
- services, err := s.projectServicesInternal(ctx, proj.ID)
- if err != nil {
- slog.WarnContext(ctx, "failed to resolve project status before rename", "projectId", proj.ID, "error", err)
- return fmt.Errorf("project must be stopped before renaming (current status: %s): failed to verify live status: %w", proj.Status, err)
+ if composeContent != nil {
+ if writeErr := projects.WriteComposeFile(ctx, projectsDirectory, proj.Path, *composeContent); writeErr != nil {
+ return fmt.Errorf("failed to save project files: %w", writeErr)
+ }
}
-
- status := ProjectStatus(listing.ProjectStatus(services))
- if status != ProjectStatusStopped {
- return fmt.Errorf("project must be stopped before renaming (current status: %s)", status)
+ if overrideErr := projects.ApplyOverrideFileChange(ctx, projectsDirectory, proj.Path, overrideContent); overrideErr != nil {
+ return fmt.Errorf("failed to save project files: %w", overrideErr)
}
-
- serviceCount, runningCount := listing.ServiceCounts(services)
- proj.Status = ProjectStatusStopped
- proj.StatusReason = nil
- proj.ServiceCount = serviceCount
- proj.RunningCount = runningCount
return nil
}
-func (s *ProjectService) applyProjectRenameIfNeeded(ctx context.Context, proj *Project, name *string, projectsDirectory string) error {
- if name == nil {
- return nil
- }
-
- newName := strings.TrimSpace(*name)
- if newName == "" || proj.Name == newName {
- return nil
- }
-
+// applyProjectRename moves a stopped project's directory to its sanitized new
+// name under the projects directory and updates the row fields.
+func (s *ProjectService) applyProjectRename(ctx context.Context, proj *Project, newName, projectsDirectory string) error {
if proj.Status != ProjectStatusStopped {
return fmt.Errorf("project must be stopped before renaming (current status: %s)", proj.Status)
}
@@ -3716,36 +3172,28 @@ func (s *ProjectService) applyProjectRenameIfNeeded(ctx context.Context, proj *P
// UpdateProjectServiceImages persists selected service image tags before recreating them.
func (s *ProjectService) UpdateProjectServiceImages(ctx context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange, user usertypes.Actor) error {
- services, err := s.persistProjectImageChangesInternal(ctx, projectID, changes)
- if err != nil {
- return err
- }
- return s.updateProjectServicesInternal(ctx, projectID, services, user)
-}
-
-func (s *ProjectService) persistProjectImageChangesInternal(ctx context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange) ([]string, error) {
if len(changes) == 0 {
- return nil, errors.New("service image changes are required")
+ return errors.New("service image changes are required")
}
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
- return nil, err
+ return err
}
- if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {
- return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")
+ if gitOpsSyncID(proj) != "" {
+ return errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")
}
- effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
+ effective, _, err := s.loadComposeProjectForProject(ctx, proj, nil)
if err != nil {
- return nil, fmt.Errorf("load project for tag update: %w", err)
+ return fmt.Errorf("load project for tag update: %w", err)
}
services, err := s.updates.ApplyImageChanges(ctx, proj.Path, effective, changes)
if err != nil {
- return nil, err
+ return err
}
- s.invalidateProjectCachesInternal(projectID)
+ s.invalidateProjectCaches(projectID)
// Keep the desired source on deployment failure: Compose may have partially
// recreated services, and the pending update must remain retryable.
- return services, nil
+ return s.UpdateProjectServices(ctx, projectID, services, user, false)
}
func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID string) (*workspacetypes.Workspace, error) {
@@ -3756,11 +3204,11 @@ func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID stri
if ensureProjectPathUnderRootErr := s.EnsureProjectPathUnderRoot(ctx, proj, false); ensureProjectPathUnderRootErr != nil {
return nil, ensureProjectPathUnderRootErr
}
- ownedPaths, ownedErr := s.gitOpsOwnedWorkspacePathsInternal(ctx, proj)
+ ownedPaths, ownedErr := s.gitOpsOwnedWorkspacePaths(ctx, proj)
if ownedErr != nil {
ownedPaths = nil
}
- return s.workspace.Read(ctx, proj.Path, s.workspaceComposeFileNameInternal(ctx, proj), ownedPaths)
+ return s.workspace.Read(ctx, proj.Path, s.workspaceComposeFileName(ctx, proj), ownedPaths)
}
func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (*workspacetypes.FileContent, error) {
@@ -3768,11 +3216,11 @@ func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID,
if err != nil {
return nil, err
}
- ownedPaths, ownedErr := s.gitOpsOwnedWorkspacePathsInternal(ctx, proj)
+ ownedPaths, ownedErr := s.gitOpsOwnedWorkspacePaths(ctx, proj)
if ownedErr != nil {
ownedPaths = nil
}
- return s.workspace.File(ctx, proj.Path, s.workspaceComposeFileNameInternal(ctx, proj), relativePath, ownedPaths)
+ return s.workspace.File(ctx, proj.Path, s.workspaceComposeFileName(ctx, proj), relativePath, ownedPaths)
}
func (s *ProjectService) DownloadProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (io.ReadCloser, int64, string, error) {
@@ -3780,32 +3228,27 @@ func (s *ProjectService) DownloadProjectWorkspaceFile(ctx context.Context, proje
if err != nil {
return nil, 0, "", err
}
- return s.workspace.Download(ctx, proj.Path, s.workspaceComposeFileNameInternal(ctx, proj), relativePath)
+ return s.workspace.Download(ctx, proj.Path, s.workspaceComposeFileName(ctx, proj), relativePath)
}
-func (
- s *ProjectService,
-) UpdateProjectWorkspace(
+func (s *ProjectService) UpdateProjectWorkspace(
ctx context.Context,
projectID string,
manifest projecttypes.WorkspaceUpdateManifest,
uploads map[int][]byte,
user usertypes.Actor,
-) (
- *workspacetypes.Workspace,
- error,
-) {
+) (*workspacetypes.Workspace, error) {
if err := workspacepkg.ValidateUpdateManifest(manifest.FileTreeRevision, len(manifest.FileChanges), 500); err != nil {
return nil, common.Classify(common.ErrProjectWorkspaceBadRequest, err)
}
- proj, err := s.getMutableProjectInternal(ctx, projectID)
+ proj, err := s.getMutableProject(ctx, projectID)
if err != nil {
return nil, err
}
// Only the paths the GitOps sync owns are locked; the rest of the
// directory is operator-owned overlay (e.g. secret env files a public
// repo cannot carry) and stays editable (#3634).
- ownedPaths, err := s.gitOpsOwnedWorkspacePathsInternal(ctx, proj)
+ ownedPaths, err := s.gitOpsOwnedWorkspacePaths(ctx, proj)
if err != nil {
return nil, err
}
@@ -3823,15 +3266,15 @@ func (
if ensureProjectEnvReadableErr := update.EnsureProjectEnvReadable(ctx, projectsDirectory, proj.Path); ensureProjectEnvReadableErr != nil {
return nil, ensureProjectEnvReadableErr
}
- if applyErr := s.workspace.Apply(ctx, projectsDirectory, proj.Path, s.workspaceComposeFileNameInternal(ctx, proj), manifest, uploads); applyErr != nil {
+ if applyErr := s.workspace.Apply(ctx, projectsDirectory, proj.Path, s.workspaceComposeFileName(ctx, proj), manifest, uploads); applyErr != nil {
return nil, applyErr
}
- s.refreshProjectImageRefsInternal(ctx, proj)
- if updateProjectStatusandCountsErr := s.updateProjectStatusandCountsInternal(ctx, proj.ID, proj.Status); updateProjectStatusandCountsErr != nil {
+ s.refreshProjectImageRefs(ctx, proj)
+ if updateProjectStatusandCountsErr := s.updateProjectStatusAndCounts(ctx, proj.ID, proj.Status); updateProjectStatusandCountsErr != nil {
return nil, fmt.Errorf("refresh project after workspace update: %w", updateProjectStatusandCountsErr)
}
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, database.JSON{
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, proj.ID, proj.Name, user, database.JSON{
"action": "update_project_workspace",
"fileChangeCount": len(manifest.FileChanges),
}, "could not log project workspace update")
@@ -3839,39 +3282,51 @@ func (
return s.GetProjectWorkspace(ctx, projectID)
}
-func (s *ProjectService) workspaceComposeFileNameInternal(ctx context.Context, proj *Project) string {
+func (s *ProjectService) workspaceComposeFileName(ctx context.Context, proj *Project) string {
if composeFile, err := s.ResolveProjectComposeFile(ctx, proj); err == nil {
return filepath.Base(composeFile)
}
return projects.DefaultComposeFileName
}
-// gitOpsOwnedWorkspacePathsInternal returns the workspace-relative paths owned
+// gitOpsOwnedWorkspacePaths returns the workspace-relative paths owned
// by the project's GitOps sync. Returns nil for projects without a live sync,
// including a stale gitops_managed_by marker.
-func (s *ProjectService) gitOpsOwnedWorkspacePathsInternal(ctx context.Context, proj *Project) (map[string]struct{}, error) {
- if gitOpsSyncIDInternal(proj) == "" {
+func (s *ProjectService) gitOpsOwnedWorkspacePaths(ctx context.Context, proj *Project) (map[string]struct{}, error) {
+ if gitOpsSyncID(proj) == "" {
return nil, nil
}
- syncRecord, err := loadGitOpsSyncForProjectInternal(ctx, s.db, proj.ID)
- if err != nil {
- return nil, fmt.Errorf("load gitops sync for workspace: %w", err)
- }
- if syncRecord == nil {
+ var syncRecord GitOpsSync
+ switch err := s.db.WithContext(ctx).Where("project_id = ?", proj.ID).First(&syncRecord).Error; {
+ case errors.Is(err, gorm.ErrRecordNotFound):
return nil, nil
+ case err != nil:
+ return nil, fmt.Errorf("load gitops sync for workspace: %w", err)
}
return workspace.OwnedPaths(syncRecord.SyncedFiles, syncRecord.ComposePath)
}
-func (s *ProjectService) projectServicesInternal(ctx context.Context, projectID string) ([]projecttypes.RuntimeService, error) {
+func (s *ProjectService) projectServices(ctx context.Context, projectID string) ([]projecttypes.RuntimeService, error) {
projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
return nil, err
}
- composeProject, composeFileFullPath, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
+ composeProject, composeFileFullPath, derr := s.loadComposeProjectForProject(ctx, projectFromDb, nil)
if errors.Is(derr, common.ErrProjectEnvUnreadable) {
- return s.projectServicesFromContainersInternal(ctx, projectFromDb, s.ProjectMetadata(ctx, *projectFromDb, nil))
+ // The Compose file cannot be loaded, so derive services from labeled containers.
+ containers, listErr := s.details.ComposeContainers(ctx)
+ if listErr != nil {
+ return nil, listErr
+ }
+ meta := s.ProjectMetadata(ctx, *projectFromDb, nil)
+ matched := listing.ProjectContainers(projectRecord(*projectFromDb), listing.GroupComposeContainersByProject(containers))
+ currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
+ services := make([]projecttypes.RuntimeService, 0, len(matched))
+ for _, c := range matched {
+ services = append(services, listing.RuntimeServiceFromContainer(IconCatalogForContext(ctx), c, meta, currentContainerID, currentContainerErr))
+ }
+ return services, nil
}
if derr != nil {
return []projecttypes.RuntimeService{}, fmt.Errorf("failed to load compose project in %s: %w", projectFromDb.Path, derr)
@@ -3893,120 +3348,61 @@ func (s *ProjectService) StreamProjectLogs(ctx context.Context, projectID string
return projectdetails.Logs(ctx, proj.Name, logsChan, follow, tail, since, timestamps)
}
-// loadComposeMetadataForSyncInternal resolves discovery settings and loads a
-// discovered directory's compose identity.
-func (s *ProjectService) loadComposeMetadataForSyncInternal(ctx context.Context, dirPath, dirName string) (projecttypes.ComposeIdentity, error) {
- cfg := s.settingsService.GetSettingsOrDefaults(ctx)
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(cfg.ProjectsDirectory.Value))
- if err != nil {
- return projecttypes.ComposeIdentity{ResolvedProjectName: projects.NormalizeProjectName(dirName)}, err
- }
- autoInjectEnv := kit.ParseOrDefault(cfg.AutoInjectEnv.Value, false, strconv.ParseBool)
- return projectsync.LoadComposeMetadata(ctx, dirPath, dirName, projectsDirectory, autoInjectEnv, s.projectPathMapperInternal(ctx))
-}
-
func (s *ProjectService) GetProjectStatusCounts(ctx context.Context) (projecttypes.StatusCounts, error) {
var projectsList []Project
if listProjectsErr := s.db.WithContext(ctx).Find(&projectsList).Error; listProjectsErr != nil {
return projecttypes.StatusCounts{}, fmt.Errorf("failed to list projects: %w", listProjectsErr)
}
- return s.listing.StatusCounts(ctx, projectRecordsInternal(projectsList)), nil
+ return s.listing.StatusCounts(ctx, projectRecords(projectsList)), nil
}
-// applyProjectPresentationInternal resolves compose metadata for projectsList
-// and fills the presentation fields of details, which align by index.
-func (s *ProjectService) applyProjectPresentationInternal(ctx context.Context, projectsList []Project, details []projecttypes.Details, metaEnv *projectMetadataEnvInternal) {
- if len(projectsList) == 0 {
- return
- }
- metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)
- listing.ApplyPresentation(ctx, metaEnv.projectsDirectory, IconCatalogForContext(ctx), projectRecordsInternal(projectsList), details, metas)
-}
-
-// projectListRowsInternal builds list rows and persists service counts
-// inferred from live containers.
-func (s *ProjectService) projectListRowsInternal(ctx context.Context, projectsDir string, projectsList []Project, snapshot listing.Snapshot) []projecttypes.Details {
- rows, inferredCounts := listing.Rows(projectsDir, IconCatalogForContext(ctx), projectRecordsInternal(projectsList), snapshot)
- s.persistInferredServiceCountsInternal(ctx, inferredCounts)
- return rows
-}
-
-// buildKnownComposeProjectNameSetInternal collects every project name Arcane
-// tracks. projectsArrayIsComplete tells it the caller already loaded the full
-// table (not a filtered page), so the catch-all re-query can be skipped.
-func (s *ProjectService) buildKnownComposeProjectNameSetInternal(ctx context.Context, projectsArray []Project, projectsArrayIsComplete bool) map[string]struct{} {
- known := listing.KnownComposeProjectNames(projectRecordsInternal(projectsArray))
- if s.db == nil || projectsArrayIsComplete {
- return known
- }
-
- var allProjects []Project
- if err := s.db.WithContext(ctx).Select("name", "compose_project_name").Find(&allProjects).Error; err != nil {
- slog.WarnContext(ctx, "failed to load known project names for compose update discovery", "error", err)
- return known
- }
- maps.Copy(known, listing.KnownComposeProjectNames(projectRecordsInternal(allProjects)))
- return known
-}
-
-func (s *ProjectService) appendDiscoveredComposeProjectUpdatesInternal(
- ctx context.Context,
- params pagination.QueryParams,
- projectsArray []Project,
- items []projecttypes.Details,
- snapshot listing.Snapshot,
-) []projecttypes.Details {
- if !listing.ShouldIncludeDiscoveredComposeProjectUpdates(params) {
- return items
- }
- containers, err := snapshot.Containers()
- if err != nil {
- slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", err)
- return items
- }
-
- knownProjectNames := s.buildKnownComposeProjectNameSetInternal(ctx, projectsArray, false)
- discovered := s.listing.DiscoveredUpdateRows(ctx, containers, knownProjectNames, IconCatalogForContext(ctx))
- if len(discovered) == 0 {
- return items
- }
-
- return append(items, discovered...)
-}
-
-// countDiscoveredComposeProjectUpdatesInternal counts compose projects running on
-// the daemon that Arcane does not track but that have a pending image update, so
-// the dashboard badge matches the projects table. Errors are logged and counted
-// as zero: a missing container list should degrade the badge, not fail the load.
-func (s *ProjectService) countDiscoveredComposeProjectUpdatesInternal(ctx context.Context, projectsArray []Project, projectsArrayIsComplete bool, allContainers []container.Summary) int {
- if allContainers == nil {
- var err error
- allContainers, err = s.details.ComposeContainers(ctx)
- if err != nil {
- slog.WarnContext(ctx, "failed to list compose containers for project update count", "error", err)
- return 0
+// projectListRows builds list rows and persists live-inferred service counts
+// over stored zeros, since SQL sorts and paginates on service_count.
+func (s *ProjectService) projectListRows(ctx context.Context, projectsDir string, projectsList []Project, snapshot listing.Snapshot) []projecttypes.Details {
+ rows, inferredCounts := listing.Rows(projectsDir, IconCatalogForContext(ctx), projectRecords(projectsList), snapshot)
+ ids := slices.Collect(maps.Keys(inferredCounts))
+ for chunk := range slices.Chunk(ids, inferredServiceCountBatchSize) {
+ var caseExpr strings.Builder
+ args := make([]any, 0, 2*len(chunk))
+ caseExpr.WriteString("CASE id")
+ for _, id := range chunk {
+ caseExpr.WriteString(" WHEN ? THEN ?")
+ args = append(args, id, inferredCounts[id])
+ }
+ caseExpr.WriteString(" ELSE service_count END")
+ if err := s.db.WithContext(ctx).Model(&Project{}).
+ Where("id IN ? AND service_count = 0", chunk).
+ Update("service_count", gorm.Expr(caseExpr.String(), args...)).Error; err != nil {
+ slog.WarnContext(ctx, "failed to persist inferred project service counts", "count", len(chunk), "error", err)
+ break
}
}
- knownProjectNames := s.buildKnownComposeProjectNameSetInternal(ctx, projectsArray, projectsArrayIsComplete)
- return s.listing.CountDiscoveredUpdates(ctx, allContainers, knownProjectNames, IconCatalogForContext(ctx))
+ return rows
}
// GetProjectTags returns the effective UI and Compose tag associations for a project.
func (s *ProjectService) GetProjectTags(ctx context.Context, projectID string) ([]projecttypes.Tag, error) {
- tagsByProject, err := s.loadProjectTagsInternal(ctx, []string{projectID})
- if err != nil {
- return nil, err
+ var rows []projecttypes.TagAssignment
+ if err := s.db.WithContext(ctx).Model(&ProjectTag{}).Where("project_id = ?", projectID).Order("name, source, color").Find(&rows).Error; err != nil {
+ return nil, fmt.Errorf("load project tags: %w", err)
}
- return tagsByProject[projectID], nil
+ return tags.Group(rows)[projectID], nil
}
// ListProjectTagOptions returns the distinct tag names and colors available in the current environment.
func (s *ProjectService) ListProjectTagOptions(ctx context.Context) ([]projecttypes.TagOption, error) {
- var rows []ProjectTag
- if err := s.db.WithContext(ctx).Order("name, source DESC, color").Find(&rows).Error; err != nil {
+ var rows []projecttypes.TagAssignment
+ if err := s.db.WithContext(ctx).Model(&ProjectTag{}).Order("name, source DESC, color").Find(&rows).Error; err != nil {
return nil, fmt.Errorf("list project tag options: %w", err)
}
- return tags.Options(tagAssignmentsInternal(rows)), nil
+ // Rows are ordered by name with the UI source first, so each name's first row wins.
+ options := make([]projecttypes.TagOption, 0)
+ for _, row := range rows {
+ if len(options) == 0 || options[len(options)-1].Name != row.Name {
+ options = append(options, projecttypes.TagOption{Name: row.Name, Color: row.Color})
+ }
+ }
+ return options, nil
}
// ListProjectReferences returns the ID and name of every project, including archived ones, without runtime state.
@@ -4030,18 +3426,18 @@ func (s *ProjectService) UpdateProjectTag(ctx context.Context, projectID, name s
if findProjectErr := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&projectModel, "id = ?", projectID).Error; findProjectErr != nil {
return fmt.Errorf("find project for tag update: %w", findProjectErr)
}
- return tags.ApplyUpdate(tagStoreInternal{tx: tx}, projectID, normalized, normalizedColor, attached)
+ return tags.ApplyUpdate(tagStore{tx: tx}, projectID, normalized, normalizedColor, attached)
})
if err != nil {
return nil, err
}
metadata := database.JSON{"action": "update_tags", "projectID": projectID, "projectName": projectModel.Name, "tag": normalized, "attached": attached}
- s.logProjectEventInternal(ctx, event.EventTypeProjectUpdate, projectID, projectModel.Name, user, metadata, "could not log project tag update")
+ s.logProjectEvent(ctx, event.EventTypeProjectUpdate, projectID, projectModel.Name, user, metadata, "could not log project tag update")
return s.GetProjectTags(ctx, projectID)
}
-func (s *ProjectService) reconcileComposeProjectTagsInternal(ctx context.Context, projectID string, composeTags []projecttypes.TagOption) error {
+func (s *ProjectService) reconcileComposeProjectTags(ctx context.Context, projectID string, composeTags []projecttypes.TagOption) error {
normalized, err := tags.NormalizeComposeProjectTags(composeTags)
if err != nil {
return err
@@ -4051,28 +3447,6 @@ func (s *ProjectService) reconcileComposeProjectTagsInternal(ctx context.Context
if findProjectErr := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Select("id").First(&projectModel, "id = ?", projectID).Error; findProjectErr != nil {
return fmt.Errorf("find project for Compose tag reconciliation: %w", findProjectErr)
}
- return tags.ReplaceCompose(tagStoreInternal{tx: tx}, projectID, normalized)
+ return tags.ReplaceCompose(tagStore{tx: tx}, projectID, normalized)
})
}
-
-func (s *ProjectService) loadProjectTagsInternal(ctx context.Context, projectIDs []string) (map[string][]projecttypes.Tag, error) {
- if len(projectIDs) == 0 {
- return make(map[string][]projecttypes.Tag), nil
- }
- var rows []ProjectTag
- if err := s.db.WithContext(ctx).Where("project_id IN ?", projectIDs).Order("project_id, name, source, color").Find(&rows).Error; err != nil {
- return nil, fmt.Errorf("load project tags: %w", err)
- }
- return tags.Group(tagAssignmentsInternal(rows)), nil
-}
-
-func (s *ProjectService) enrichProjectsWithTagsInternal(ctx context.Context, items []projecttypes.Details) error {
- tagsByProject, err := s.loadProjectTagsInternal(ctx, tags.TrackedProjectIDs(items))
- if err != nil {
- return err
- }
- for index := range items {
- items[index].Tags = tagsByProject[items[index].ID]
- }
- return nil
-}
diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.go
index 78a1e003b..3048985ab 100644
--- a/backend/internal/project/service_test.go
+++ b/backend/internal/project/service_test.go
@@ -3,6 +3,7 @@ package project
import (
"cmp"
"context"
+ "encoding/binary"
"encoding/json"
"errors"
"fmt"
@@ -30,6 +31,7 @@ import (
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
"github.com/libtnb/sqlite"
"github.com/moby/moby/api/pkg/authconfig"
+ "github.com/moby/moby/api/pkg/stdcopy"
"github.com/moby/moby/api/types/container"
dockertypesimage "github.com/moby/moby/api/types/image"
dockerregistry "github.com/moby/moby/api/types/registry"
@@ -55,7 +57,6 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/kv"
"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/deployment"
projectdetails "github.com/getarcaneapp/arcane/backend/v2/internal/project/children/details"
- "github.com/getarcaneapp/arcane/backend/v2/internal/project/children/lifecycle"
"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/listing"
projectsync "github.com/getarcaneapp/arcane/backend/v2/internal/project/children/sync"
"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/tags"
@@ -86,7 +87,7 @@ func (testBuildBuilder) BuildSettings() buildtypes.BuildSettings {
return buildtypes.BuildSettings{}
}
-var _ buildServiceInternal = testBuildBuilder{}
+var _ builder = testBuildBuilder{}
func setupProjectTestDB(t *testing.T) *database.DB {
t.Helper()
@@ -98,7 +99,7 @@ func setupProjectTestDB(t *testing.T) *database.DB {
func TestUpdateProjectWorkspaceRejectsInvalidManifestBeforeProjectLookup(t *testing.T) {
service := &ProjectService{}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
_, err := service.UpdateProjectWorkspace(t.Context(), "missing", projecttypes.WorkspaceUpdateManifest{}, nil, usertypes.Actor{})
require.ErrorIs(t, err, common.ErrProjectWorkspaceBadRequest)
@@ -129,7 +130,7 @@ func TestValidateWorkspaceChangesAgainstGitOps(t *testing.T) {
require.NoError(t, err)
}
-func newSettingsServiceForTestInternal(t *testing.T, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
+func newSettingsServiceForTest(t *testing.T, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
svc, err := settings.NewSettingsService(ctx, db)
if err == nil {
@@ -138,7 +139,7 @@ func newSettingsServiceForTestInternal(t *testing.T, ctx context.Context, db *da
return svc, err
}
-func newTestDockerClientInternal(t *testing.T, server *httptest.Server) *client.Client {
+func newTestDockerClient(t *testing.T, server *httptest.Server) *client.Client {
t.Helper()
cli, err := client.New(
@@ -151,14 +152,14 @@ func newTestDockerClientInternal(t *testing.T, server *httptest.Server) *client.
return cli
}
-func decodeRegistryAuthInternal(t *testing.T, encoded string) dockerregistry.AuthConfig {
+func decodeRegistryAuth(t *testing.T, encoded string) dockerregistry.AuthConfig {
t.Helper()
cfg, err := authconfig.Decode(encoded)
require.NoError(t, err)
return *cfg
}
-func newImagePullServerWithObserverInternal(t *testing.T, inspectByRef map[string]dockertypesimage.InspectResponse, onPull func(fullRef, authHeader string)) *httptest.Server {
+func newImagePullServerWithObserver(t *testing.T, inspectByRef map[string]dockertypesimage.InspectResponse, onPull func(fullRef, authHeader string)) *httptest.Server {
t.Helper()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -207,7 +208,7 @@ func newImagePullServerWithObserverInternal(t *testing.T, inspectByRef map[strin
func TestProjectService_RefreshProjectImageRefs_PersistsBuildMetadata(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectPath := t.TempDir()
@@ -231,7 +232,7 @@ func TestProjectService_RefreshProjectImageRefs_PersistsBuildMetadata(t *testing
require.NoError(t, db.Create(proj).Error)
svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- svc.refreshProjectImageRefsInternal(ctx, proj)
+ svc.refreshProjectImageRefs(ctx, proj)
var saved Project
require.NoError(t, db.First(&saved, "id = ?", proj.ID).Error)
@@ -243,7 +244,7 @@ func TestProjectService_RefreshProjectImageRefs_PersistsBuildMetadata(t *testing
func TestProjectService_BackfillProjectImageRefs_RetriesOnlyMissingMetadata(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
validPath := t.TempDir()
@@ -299,12 +300,12 @@ func TestProjectService_BackfillProjectImageRefs_RetriesOnlyMissingMetadata(t *t
assert.Equal(t, "[]", *savedRegular.BuildImageRefsJSON)
}
-func setupProjectDestroyTestServiceInternal(t *testing.T) (*ProjectService, *database.DB, string) {
+func setupProjectDestroyTestService(t *testing.T) (*ProjectService, *database.DB, string) {
t.Helper()
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsDir := t.TempDir()
@@ -316,7 +317,7 @@ func setupProjectDestroyTestServiceInternal(t *testing.T) (*ProjectService, *dat
func TestProjectService_DestroyProject_RemovesFilesWhenRequested(t *testing.T) {
ctx := t.Context()
- svc, db, projectsDir := setupProjectDestroyTestServiceInternal(t)
+ svc, db, projectsDir := setupProjectDestroyTestService(t)
projectPath := filepath.Join(projectsDir, "demo-remove")
require.NoError(t, os.MkdirAll(projectPath, 0o755))
@@ -340,7 +341,7 @@ func TestProjectService_DestroyProject_RemovesFilesWhenRequested(t *testing.T) {
func TestProjectService_DestroyProject_PreservesFilesWhenRequested(t *testing.T) {
ctx := t.Context()
- svc, db, projectsDir := setupProjectDestroyTestServiceInternal(t)
+ svc, db, projectsDir := setupProjectDestroyTestService(t)
projectPath := filepath.Join(projectsDir, "demo-preserve")
require.NoError(t, os.MkdirAll(projectPath, 0o755))
@@ -375,7 +376,7 @@ func TestProjectService_GetProjectFromDatabaseByID(t *testing.T) {
ctx := t.Context()
// Setup dependencies
- settingsService, _ := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, _ := newSettingsServiceForTest(t, ctx, db)
svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
// Create test project
@@ -397,7 +398,7 @@ func TestProjectService_GetProjectFromDatabaseByID(t *testing.T) {
assert.Contains(t, err.Error(), "project not found")
}
-func TestProjectService_UpdateProjectStatusInternal(t *testing.T) {
+func TestProjectService_UpdateProjectStatus(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
svc := NewProjectService(db, nil, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
@@ -408,7 +409,7 @@ func TestProjectService_UpdateProjectStatusInternal(t *testing.T) {
}
require.NoError(t, db.Create(proj).Error)
- err := svc.updateProjectStatusInternal(ctx, "p1", ProjectStatusRunning)
+ err := svc.updateProjectStatus(ctx, "p1", ProjectStatusRunning)
require.NoError(t, err)
var updated Project
@@ -487,7 +488,7 @@ func TestProjectService_GetProjectByComposeName(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, original.ID, found.ID)
- cachedProjectID, cached := svc.composeNames.projectIDInternal("myproject").Get()
+ cachedProjectID, cached := svc.composeNames.projectID("myproject").Get()
require.True(t, cached)
assert.Equal(t, original.ID, cachedProjectID)
@@ -504,7 +505,7 @@ func TestProjectService_GetProjectByComposeName(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, replacement.ID, found.ID)
- cachedProjectID, cached = svc.composeNames.projectIDInternal("myproject").Get()
+ cachedProjectID, cached = svc.composeNames.projectID("myproject").Get()
require.True(t, cached)
assert.Equal(t, replacement.ID, cachedProjectID)
})
@@ -524,7 +525,7 @@ func TestProjectService_GetProjectByComposeName(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, original.ID, found.ID)
- cachedProjectID, cached := svc.composeNames.projectIDInternal("myapp").Get()
+ cachedProjectID, cached := svc.composeNames.projectID("myapp").Get()
require.True(t, cached)
assert.Equal(t, original.ID, cachedProjectID)
@@ -537,7 +538,7 @@ func TestProjectService_GetProjectByComposeName(t *testing.T) {
require.Error(t, err)
assert.Contains(t, err.Error(), "project not found")
- _, cached = svc.composeNames.projectIDInternal("myapp").Get()
+ _, cached = svc.composeNames.projectID("myapp").Get()
assert.False(t, cached)
})
}
@@ -549,7 +550,7 @@ func TestProjectService_PullProjectImages_UpdatesCurrentImageRecordAfterPull(t *
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -559,7 +560,7 @@ func TestProjectService_PullProjectImages_UpdatesCurrentImageRecordAfterPull(t *
imageDigest := digest.FromString("team-app-digest").String()
buildRepository := "arcane.local/demo-builder/service"
- server := newImagePullServerWithObserverInternal(t, map[string]dockertypesimage.InspectResponse{
+ server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
imageRef: {
ID: imageID,
RepoTags: []string{imageRef},
@@ -567,7 +568,7 @@ func TestProjectService_PullProjectImages_UpdatesCurrentImageRecordAfterPull(t *
},
}, nil)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
eventService := event.NewEventService(db, nil, nil)
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, nil, nil)
@@ -647,7 +648,7 @@ func TestProjectService_EnsureImagesPresent_UpdatesCurrentImageRecordAfterPull(t
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
imageRef := "registry.example.com/team/api:2.0.0"
@@ -655,7 +656,7 @@ func TestProjectService_EnsureImagesPresent_UpdatesCurrentImageRecordAfterPull(t
imageID := "sha256:team-api"
imageDigest := digest.FromString("team-api-digest").String()
- server := newImagePullServerWithObserverInternal(t, map[string]dockertypesimage.InspectResponse{
+ server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
imageRef: {
ID: imageID,
RepoTags: []string{imageRef},
@@ -663,7 +664,7 @@ func TestProjectService_EnsureImagesPresent_UpdatesCurrentImageRecordAfterPull(t
},
}, nil)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
eventService := event.NewEventService(db, nil, nil)
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, nil, nil)
@@ -715,7 +716,7 @@ func TestProjectService_PullImageForService_UpdatesCurrentImageRecordAfterPull(t
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
imageRef := "registry.example.com/team/worker:3.1.4"
@@ -723,7 +724,7 @@ func TestProjectService_PullImageForService_UpdatesCurrentImageRecordAfterPull(t
imageID := "sha256:team-worker"
imageDigest := digest.FromString("team-worker-digest").String()
- server := newImagePullServerWithObserverInternal(t, map[string]dockertypesimage.InspectResponse{
+ server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
imageRef: {
ID: imageID,
RepoTags: []string{imageRef},
@@ -731,7 +732,7 @@ func TestProjectService_PullImageForService_UpdatesCurrentImageRecordAfterPull(t
},
}, nil)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
eventService := event.NewEventService(db, nil, nil)
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, nil, nil)
@@ -760,11 +761,11 @@ func TestProjectService_PullImageForService_UpdatesCurrentImageRecordAfterPull(t
assert.Equal(t, imageDigest, mo.PointerToOption(currentRecord.LatestDigest).OrEmpty())
}
-func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSuccess(t *testing.T) {
+func TestProjectService_ComposePullSelectedServices_ReconcilesOnlyOnSuccess(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
privateImageRef := "registry.example.com/team/app:9.9.9"
@@ -778,7 +779,7 @@ func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSucc
pullsByRef := map[string]int{}
authHeadersByRef := map[string]string{}
- server := newImagePullServerWithObserverInternal(t, map[string]dockertypesimage.InspectResponse{
+ server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
privateImageRef: {
ID: privateImageID,
RepoTags: []string{privateImageRef},
@@ -794,7 +795,7 @@ func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSucc
authHeadersByRef[fullRef] = authHeader
})
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
eventService := event.NewEventService(db, nil, nil)
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, nil, nil)
@@ -854,7 +855,7 @@ func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSucc
assert.Equal(t, 1, pullsByRef[publicImageRef], "selected public image should still be pulled")
assert.Len(t, pullsByRef, 2, "build-backed services should not trigger image pulls")
- privateAuth := decodeRegistryAuthInternal(t, authHeadersByRef[privateImageRef])
+ privateAuth := decodeRegistryAuth(t, authHeadersByRef[privateImageRef])
assert.Equal(t, "arcane-user", privateAuth.Username)
assert.Equal(t, "arcane-token", privateAuth.Password)
assert.Equal(t, "registry.example.com", privateAuth.ServerAddress)
@@ -880,11 +881,11 @@ func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSucc
assert.Equal(t, publicImageDigest, mo.PointerToOption(publicCurrentRecord.LatestDigest).OrEmpty())
}
-func TestProjectService_ComposePullSelectedServicesInternal_LeavesRecordsWhenPullFails(t *testing.T) {
+func TestProjectService_ComposePullSelectedServices_LeavesRecordsWhenPullFails(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
imageRef := "registry.example.com/team/app:9.9.9"
@@ -899,7 +900,7 @@ func TestProjectService_ComposePullSelectedServicesInternal_LeavesRecordsWhenPul
}))
t.Cleanup(failingServer.Close)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, failingServer)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, failingServer)}
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil), nil, nil)
svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, nil, nil, config.Load(), nil, nil)
@@ -937,13 +938,13 @@ func TestProjectService_ComposePullSelectedServicesInternal_LeavesRecordsWhenPul
assert.Zero(t, count)
}
-func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *testing.T) {
+func TestProjectService_UpdateProjectServicesHardFailsWhenPullFails(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -957,7 +958,7 @@ func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *t
}))
t.Cleanup(failingServer.Close)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, failingServer)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, failingServer)}
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil), nil, nil)
@@ -994,12 +995,12 @@ func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *t
CheckTime: time.Now().UTC().Add(-time.Hour),
}).Error)
- originalComposeUp := composeUpProjectServicesInternal
+ originalComposeUp := composeUpProjectServices
t.Cleanup(func() {
- composeUpProjectServicesInternal = originalComposeUp
+ composeUpProjectServices = originalComposeUp
})
upCalled := false
- composeUpProjectServicesInternal = func(context.Context, *types.Project, []string, bool, bool, bool, map[string]dockerregistry.AuthConfig, time.Duration) error {
+ composeUpProjectServices = func(context.Context, *types.Project, []string, bool, bool, bool, map[string]dockerregistry.AuthConfig, time.Duration) error {
upCalled = true
return errors.New("compose up should not run")
}
@@ -1019,13 +1020,13 @@ func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *t
assert.True(t, persistedRecord.HasUpdate)
}
-func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T) {
+func TestProjectService_UpdateProjectServicesForcesRecreate(t *testing.T) {
ctx := t.Context()
db := setupProjectTestDB(t)
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -1034,7 +1035,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
imageID := "sha256:project-update-force"
imageDigest := digest.FromString("project-update-force-digest").String()
- server := newImagePullServerWithObserverInternal(t, map[string]dockertypesimage.InspectResponse{
+ server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
imageRef: {
ID: imageID,
RepoTags: []string{imageRef},
@@ -1044,7 +1045,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
assert.Equal(t, imageRef, fullRef, "namespace dependents must not be pulled")
})
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
eventService := event.NewEventService(db, nil, nil)
imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, nil, nil)
@@ -1068,7 +1069,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
),
)
- composeContainerInternal := func(service string, state container.ContainerState) container.Summary {
+ composeContainer := func(service string, state container.ContainerState) container.Summary {
return container.Summary{
ID: service + "-container",
Names: []string{"/compose-update-force-" + service + "-1"},
@@ -1076,12 +1077,12 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
Labels: map[string]string{api.ProjectLabel: "compose-update-force", api.ServiceLabel: service, api.ConfigHashLabel: service + "-hash"},
}
}
- runtimeServer := newProjectRuntimeDockerServerInternal(t, []container.Summary{
- composeContainerInternal("app", container.StateRunning),
- composeContainerInternal("sidecar", container.StateRunning),
- composeContainerInternal("dormant", container.StateExited),
+ runtimeServer := newProjectRuntimeDockerServer(t, []container.Summary{
+ composeContainer("app", container.StateRunning),
+ composeContainer("sidecar", container.StateRunning),
+ composeContainer("dormant", container.StateExited),
})
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, runtimeServer.URL))
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, runtimeServer.URL))
projectRecord := &Project{
ID: "project-update-force",
@@ -1092,20 +1093,20 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
}
require.NoError(t, db.Create(projectRecord).Error)
- originalComposeStop := composeStopProjectServicesInternal
- originalComposeUp := composeUpProjectServicesInternal
+ originalComposeStop := composeStopProjectServices
+ originalComposeUp := composeUpProjectServices
t.Cleanup(func() {
- composeStopProjectServicesInternal = originalComposeStop
- composeUpProjectServicesInternal = originalComposeUp
+ composeStopProjectServices = originalComposeStop
+ composeUpProjectServices = originalComposeUp
})
var stopped []string
- composeStopProjectServicesInternal = func(_ context.Context, _ *types.Project, services []string) error {
+ composeStopProjectServices = func(_ context.Context, _ *types.Project, services []string) error {
stopped = services
return nil
}
upCalled := false
forceRecreate := false
- composeUpProjectServicesInternal = func(
+ composeUpProjectServices = func(
_ context.Context,
selected *types.Project,
services []string,
@@ -1133,7 +1134,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
assert.True(t, forceRecreate, "service updates must force recreate after pulling the updated image")
}
-type fakeProjectVolumeRenameMigrationInternal struct {
+type fakeProjectVolumeRenameMigration struct {
applyCalled bool
commitCalled bool
rollbackCalled bool
@@ -1142,17 +1143,17 @@ type fakeProjectVolumeRenameMigrationInternal struct {
rollbackErr error
}
-func (m *fakeProjectVolumeRenameMigrationInternal) Apply(context.Context) error {
+func (m *fakeProjectVolumeRenameMigration) Apply(context.Context) error {
m.applyCalled = true
return m.applyErr
}
-func (m *fakeProjectVolumeRenameMigrationInternal) Rollback(context.Context) error {
+func (m *fakeProjectVolumeRenameMigration) Rollback(context.Context) error {
m.rollbackCalled = true
return m.rollbackErr
}
-func (m *fakeProjectVolumeRenameMigrationInternal) Commit(context.Context) error {
+func (m *fakeProjectVolumeRenameMigration) Commit(context.Context) error {
m.commitCalled = true
return m.commitErr
}
@@ -1164,7 +1165,7 @@ func TestProjectService_UpdateProject_RenameFailsWhenVolumeMigrationPreparationF
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -1199,9 +1200,9 @@ func TestProjectService_UpdateProject_RenameFailsWhenVolumeMigrationPreparationF
}
}))
t.Cleanup(dockerServer.Close)
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, dockerServer.URL))
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, dockerServer.URL))
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, dockerServer)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
svc := NewProjectService(db, settingsService, eventService, nil, dockerService, nil, nil, nil, config.Load(), nil, nil)
originalDirName := "Foo"
@@ -1252,13 +1253,13 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_AppliesVolumeMigrati
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- migration := &fakeProjectVolumeRenameMigrationInternal{}
+ migration := &fakeProjectVolumeRenameMigration{}
originalDirName := "Foo"
originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
@@ -1275,7 +1276,7 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_AppliesVolumeMigrati
projectForUpdate := *project
journalActive := false
projectStateCommitted := false
- err = svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
+ err = svc.applyProjectUpdate(ctx, &projectForUpdate, true, "bar", projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
require.NoError(t, err)
assert.True(t, migration.applyCalled)
@@ -1299,7 +1300,7 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -1330,7 +1331,7 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
}))
t.Cleanup(dockerServer.Close)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, dockerServer)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
svc := NewProjectService(db, settingsService, nil, nil, dockerService, nil, nil, nil, config.Load(), nil, nil)
projectPath := filepath.Join(projectsDir, "nginx")
@@ -1349,22 +1350,22 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
t.Run("skips volume made explicit in pending compose", func(t *testing.T) {
newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n name: fixed-data\n"
- migration, prepareProjectRenameVolumeMigrationForUpdateErr := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil)
+ migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)
- require.NoError(t, prepareProjectRenameVolumeMigrationForUpdateErr)
+ require.NoError(t, prepareErr)
require.Nil(t, migration)
bytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
require.NoError(t, readErr)
require.Equal(t, oldCompose, string(bytes))
- require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
})
t.Run("plans unchanged auto-managed volume from pending compose", func(t *testing.T) {
newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"
- migration, prepareProjectRenameVolumeMigrationForUpdateErr := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil)
+ migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)
- require.NoError(t, prepareProjectRenameVolumeMigrationForUpdateErr)
+ require.NoError(t, prepareErr)
require.NotNil(t, migration)
journalSource, ok := migration.(volumetypes.JournalSource)
require.True(t, ok)
@@ -1373,15 +1374,15 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
require.Equal(t, "data", journalVolumes[0].Key)
require.Equal(t, "nginx_data", journalVolumes[0].OldName)
require.Equal(t, "web_data", journalVolumes[0].NewName)
- require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
})
t.Run("plans auto-managed volume when pending compose name renames project", func(t *testing.T) {
newCompose := "name: web\nservices:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"
- migration, prepareProjectRenameVolumeMigrationForUpdateErr := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil)
+ migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)
- require.NoError(t, prepareProjectRenameVolumeMigrationForUpdateErr)
+ require.NoError(t, prepareErr)
require.NotNil(t, migration)
journalSource, ok := migration.(volumetypes.JournalSource)
require.True(t, ok)
@@ -1390,15 +1391,15 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
require.Equal(t, "data", journalVolumes[0].Key)
require.Equal(t, "nginx_data", journalVolumes[0].OldName)
require.Equal(t, "web_data", journalVolumes[0].NewName)
- require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
})
t.Run("plans interpolated explicit name from pending compose", func(t *testing.T) {
newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n name: ${DATA_VOLUME:-nginx_data}\n"
- migration, prepareProjectRenameVolumeMigrationForUpdateErr := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil)
+ migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)
- require.NoError(t, prepareProjectRenameVolumeMigrationForUpdateErr)
+ require.NoError(t, prepareErr)
require.NotNil(t, migration)
journalSource, ok := migration.(volumetypes.JournalSource)
require.True(t, ok)
@@ -1407,7 +1408,7 @@ func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesCompose
require.Equal(t, "data", journalVolumes[0].Key)
require.Equal(t, "nginx_data", journalVolumes[0].OldName)
require.Equal(t, "web_data", journalVolumes[0].NewName)
- require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
})
}
@@ -1418,13 +1419,13 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_RollsBackVolumeMigra
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- migration := &fakeProjectVolumeRenameMigrationInternal{}
+ migration := &fakeProjectVolumeRenameMigration{}
require.NoError(t, db.Callback().Update().Before("gorm:update").Register("arcane_test_project_save_failure", func(tx *gorm.DB) {
if tx.Statement != nil && tx.Statement.Schema != nil && tx.Statement.Schema.Name == "Project" {
@@ -1447,8 +1448,8 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_RollsBackVolumeMigra
projectForUpdate := *project
journalActive := false
projectStateCommitted := false
- err = withProjectRenameRollbackInternal(ctx, &projectForUpdate, &projectStateCommitted, func() error {
- return svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
+ err = withProjectRenameRollback(ctx, &projectForUpdate, &projectStateCommitted, func() error {
+ return svc.applyProjectUpdate(ctx, &projectForUpdate, true, "bar", projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
})
require.Error(t, err)
assert.Contains(t, err.Error(), "forced project save failure")
@@ -1467,13 +1468,13 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_SucceedsCommittedRen
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- migration := &fakeProjectVolumeRenameMigrationInternal{
+ migration := &fakeProjectVolumeRenameMigration{
commitErr: errors.New("source cleanup failed"),
}
@@ -1492,8 +1493,8 @@ func TestProjectService_ApplyProjectUpdateWithRenameJournal_SucceedsCommittedRen
projectForUpdate := *project
journalActive := false
projectStateCommitted := false
- err = withProjectRenameRollbackInternal(ctx, &projectForUpdate, &projectStateCommitted, func() error {
- return svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
+ err = withProjectRenameRollback(ctx, &projectForUpdate, &projectStateCommitted, func() error {
+ return svc.applyProjectUpdate(ctx, &projectForUpdate, true, "bar", projectsDir, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
})
require.NoError(t, err)
require.True(t, migration.applyCalled)
@@ -1517,7 +1518,7 @@ func TestProjectService_UpdateProject_ClearsJournalForNonRenameWhenRecoveryDocke
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -1583,14 +1584,14 @@ func TestProjectService_UpdateProject_AllowsRenameAfterJournalRecoveryWithoutDoc
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := event.NewEventService(db, nil, nil)
kvService := kv.NewKVService(db)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), kvService, nil)
- configureProjectRuntimeDockerInternal(t, nil)
+ configureProjectRuntimeDocker(t, nil)
oldDir := "nginx"
projectPath := createComposeProjectDir(t, projectsDir, oldDir)
@@ -1647,12 +1648,12 @@ func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- configureProjectRuntimeDockerInternal(t, nil)
+ configureProjectRuntimeDocker(t, nil)
originalDirName := "Foo"
originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
@@ -1696,12 +1697,12 @@ func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *te
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- configureProjectRuntimeDockerInternal(t, nil)
+ configureProjectRuntimeDocker(t, nil)
originalDirName := "Foo"
originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
@@ -1743,7 +1744,7 @@ func TestProjectService_UpdateProject_RenameFailsWhenProjectRunning(t *testing.T
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -1787,13 +1788,13 @@ func TestProjectService_UpdateProject_RenameRejectsStaleStoppedWhenRuntimeIsRunn
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- configureProjectRuntimeDockerInternal(t, []container.Summary{
+ configureProjectRuntimeDocker(t, []container.Summary{
{
ID: "app-container",
Names: []string{"/foo-app-1"},
@@ -1845,15 +1846,15 @@ func TestProjectService_UpdateProject_RenameResolvesUnknownStoppedStatusBeforeVo
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- server := newProjectRuntimeDockerServerInternal(t, nil)
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ server := newProjectRuntimeDockerServer(t, nil)
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
originalDirName := "Foo"
originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
@@ -1903,14 +1904,14 @@ func TestProjectService_UpdateProject_RenameRejectsUnknownWhenRuntimeIsRunning(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := event.NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ server := newProjectRuntimeDockerServer(t, []container.Summary{
{
ID: "app-container",
Names: []string{"/foo-app-1"},
@@ -1925,7 +1926,7 @@ func TestProjectService_UpdateProject_RenameRejectsUnknownWhenRuntimeIsRunning(t
},
},
})
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
originalDirName := "Foo"
originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
@@ -1967,7 +1968,7 @@ func TestProjectService_UpdateProject_ValidatesComposeUsingExistingProjectName(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2010,7 +2011,7 @@ func TestProjectService_UpdateProject_AllowsMissingEnvFileDuringComposeValidatio
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2055,7 +2056,7 @@ func TestProjectService_UpdateProject_EnvRetargetWritesExplicitIdenticalComposeT
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2109,7 +2110,7 @@ func TestProjectService_UpdateProject_EnvRetargetWithoutComposePayloadPreservesN
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2161,7 +2162,7 @@ func TestProjectService_UpdateProject_EnvRetargetWritesEditedComposeToSelectedBa
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2208,7 +2209,7 @@ func TestProjectService_UpdateProject_AllowsMissingLocalIncludeDuringComposeVali
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2258,7 +2259,7 @@ func TestProjectService_CreateProject_AllowsExternalInclude(t *testing.T) {
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2289,7 +2290,7 @@ func TestProjectService_UpdateProject_AllowsExternalInclude(t *testing.T) {
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2334,7 +2335,7 @@ func TestProjectService_CreateProject_CommitsWorkspaceAndConfigurationTogether(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
svc := NewProjectService(db, settingsService, event.NewEventService(db, nil, nil), nil, nil, nil, nil, nil, config.Load(), nil, nil)
uploadIndex := 0
@@ -2369,7 +2370,7 @@ func TestProjectService_CreateProject_RollsBackInvalidWorkspaceManifest(t *testi
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
svc := NewProjectService(db, settingsService, event.NewEventService(db, nil, nil), nil, nil, nil, nil, nil, config.Load(), nil, nil)
manifest := projecttypes.CreateProjectWorkspaceManifest{FileChanges: []projecttypes.WorkspaceFileChange{{
@@ -2403,7 +2404,7 @@ func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2443,9 +2444,9 @@ func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation
assert.Equal(t, "FOO=bar\n", string(envBytes))
}
-// newProjectServiceForOverrideTestInternal builds a project with a base compose
+// newProjectServiceForOverrideTest builds a project with a base compose
// file on disk and returns the service, the project record, and the project path.
-func newProjectServiceForOverrideTestInternal(t *testing.T, dirName string) (*ProjectService, *Project, string) {
+func newProjectServiceForOverrideTest(t *testing.T, dirName string) (*ProjectService, *Project, string) {
t.Helper()
db := setupProjectTestDB(t)
ctx := t.Context()
@@ -2453,7 +2454,7 @@ func newProjectServiceForOverrideTestInternal(t *testing.T, dirName string) (*Pr
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2477,7 +2478,7 @@ func newProjectServiceForOverrideTestInternal(t *testing.T, dirName string) (*Pr
func TestProjectService_UpdateProject_CreatesOverrideWithDefaultName(t *testing.T) {
ctx := t.Context()
- svc, project, projectPath := newProjectServiceForOverrideTestInternal(t, "override-create")
+ svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-create")
override := "services:\n app:\n image: busybox:latest\n"
_, err := svc.UpdateProject(ctx, project.ID, nil, nil, nil, new(override), usertypes.Actor{
@@ -2500,7 +2501,7 @@ func TestProjectService_UpdateProject_CreatesOverrideWithDefaultName(t *testing.
func TestProjectService_UpdateProject_PreservesExistingOverrideName(t *testing.T) {
ctx := t.Context()
- svc, project, projectPath := newProjectServiceForOverrideTestInternal(t, "override-preserve")
+ svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-preserve")
// An existing docker-compose.override.yml must keep its name on edit rather
// than being rewritten to the default compose.override.yaml.
@@ -2521,7 +2522,7 @@ func TestProjectService_UpdateProject_PreservesExistingOverrideName(t *testing.T
func TestProjectService_UpdateProject_DeletesOverrideOnBlank(t *testing.T) {
ctx := t.Context()
- svc, project, projectPath := newProjectServiceForOverrideTestInternal(t, "override-delete")
+ svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-delete")
overridePath := filepath.Join(projectPath, "compose.override.yaml")
require.NoError(t, os.WriteFile(overridePath, []byte("services:\n app:\n image: busybox:latest\n"), 0o600))
@@ -2539,7 +2540,7 @@ func TestProjectService_UpdateProject_DeletesOverrideOnBlank(t *testing.T) {
func TestProjectService_UpdateProject_MergedValidationFailureLeavesDiskUnchanged(t *testing.T) {
ctx := t.Context()
baseCompose := "services:\n app:\n image: nginx:alpine\n"
- svc, project, projectPath := newProjectServiceForOverrideTestInternal(t, "override-invalid")
+ svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-invalid")
// A new base compose plus a malformed override must fail validation, and the
// backup/restore must leave both the base and the override untouched on disk.
@@ -2564,7 +2565,7 @@ func TestProjectService_UpdateProject_UsesProvidedEnvContentDuringComposeValidat
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2611,7 +2612,7 @@ func TestProjectService_UpdateProject_ReturnsEnvParseErrorDuringComposeValidatio
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2656,7 +2657,7 @@ func TestProjectService_UpdateProject_UsesGlobalEnvDuringComposeValidation(t *te
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2705,7 +2706,7 @@ func TestProjectService_UpdateProject_DoesNotResolveHostEnvThroughGlobalEnvDurin
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
t.Setenv("HOST_ONLY_PATH", "/host/secret")
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2749,7 +2750,7 @@ func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExis
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2796,7 +2797,7 @@ func TestProjectService_UpdateProject_UnchangedGitEnvLeavesFilesUntouched(t *tes
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2893,7 +2894,7 @@ func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *test
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2943,7 +2944,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOve
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -2994,7 +2995,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_PreservesGitEnvSyntax(t *testin
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3056,7 +3057,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrid
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3104,7 +3105,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3153,7 +3154,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3197,7 +3198,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_WritesAndRemovesComposeOverride
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3248,7 +3249,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValid
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3299,7 +3300,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfUndefinedComposeVar(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3347,7 +3348,7 @@ func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -3375,7 +3376,7 @@ func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.
assert.Equal(t, "BASE=git\nTOKEN=secret\n", details.EnvContent)
}
-func TestBuildProjectUpdateInfoSummaryInternal(t *testing.T) {
+func TestBuildProjectUpdateInfoSummary(t *testing.T) {
now := time.Now().UTC()
tests := []struct {
@@ -3455,7 +3456,7 @@ func TestBuildProjectUpdateInfoSummaryInternal(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- summary := BuildUpdateInfoSummary(tt.imageRefs, tt.updates)
+ summary := buildUpdateInfoSummary(tt.imageRefs, tt.updates)
require.NotNil(t, summary)
assert.Equal(t, tt.wantStatus, summary.Status)
assert.Equal(t, tt.wantCount, summary.ImageCount)
@@ -3486,7 +3487,7 @@ func TestProjectService_GetProjectDetails_IncludesUpdateInfo(t *testing.T) {
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -3534,14 +3535,14 @@ func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeSe
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
projectPath := createComposeProjectDir(t, projectsDir, "projectA")
require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n worker:\n image: busybox:latest\n"), 0o644))
- server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ server := newProjectRuntimeDockerServer(t, []container.Summary{
{
ID: "server-container",
Names: []string{"/projecta-server-1"},
@@ -3577,7 +3578,7 @@ func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeSe
},
},
})
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
projectRecord := &Project{
ID: "proj-runtime-refresh",
@@ -3607,14 +3608,14 @@ func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
projectPath := createComposeProjectDir(t, projectsDir, "projectA")
require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n"), 0o644))
- server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ server := newProjectRuntimeDockerServer(t, []container.Summary{
{
ID: "server-container",
Names: []string{"/projecta-server-1"},
@@ -3629,7 +3630,7 @@ func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(
},
},
})
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
projectRecord := &Project{
ID: "proj-runtime-services",
@@ -3654,7 +3655,7 @@ func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(
assert.Equal(t, "projecta-server-1", details.RuntimeServices[0].ContainerName)
}
-func TestBuildProjectLabelFilterAccessorInternal(t *testing.T) {
+func TestListingPage_FiltersByLabel(t *testing.T) {
items := []projecttypes.Details{
{ID: "tagged", RuntimeServices: []projecttypes.RuntimeService{
{Name: "web", ContainerLabels: map[string]string{"heal": "true"}},
@@ -3663,8 +3664,6 @@ func TestBuildProjectLabelFilterAccessorInternal(t *testing.T) {
{ID: "other", RuntimeServices: []projecttypes.RuntimeService{{Name: "web", ContainerLabels: map[string]string{"heal": "false"}}}},
{ID: "down"},
}
- paginationConfig := pagination.Config[projecttypes.Details]{FilterAccessors: []pagination.FilterAccessor[projecttypes.Details]{listing.BuildProjectLabelFilterAccessor()}}
-
tests := []struct {
name string
filter string
@@ -3678,7 +3677,7 @@ func TestBuildProjectLabelFilterAccessorInternal(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- result := paginationConfig.SearchOrderAndPaginate(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}})
+ result, _ := listing.Page(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}, Limit: -1}, func(string) bool { return true })
var got []string
for _, item := range result.Items {
got = append(got, item.ID)
@@ -3695,7 +3694,7 @@ func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -3802,7 +3801,7 @@ func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
}
}
-func TestBuildDiscoveredComposeProjectUpdateRowsInternal(t *testing.T) {
+func TestBuildDiscoveredComposeProjectUpdateRows(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
@@ -3826,7 +3825,7 @@ func TestBuildDiscoveredComposeProjectUpdateRowsInternal(t *testing.T) {
CurrentVersion: "7",
CheckTime: now,
}).Error)
- rows := discoveryListingForTestInternal(imageService).DiscoveredUpdateRows(ctx, []container.Summary{
+ rows := discoveryListingForTest(imageService).DiscoveredUpdateRows(ctx, []container.Summary{
{
ID: "media-web",
Names: []string{"/media-web-1"},
@@ -3870,7 +3869,7 @@ func TestBuildDiscoveredComposeProjectUpdateRowsInternal(t *testing.T) {
assert.Equal(t, "web", row.RuntimeServices[0].Name)
}
-func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *testing.T) {
+func TestBuildDiscoveredComposeProjectUpdateRows_FallsBackToImageID(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
@@ -3919,7 +3918,7 @@ func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *t
},
},
}
- rows := discoveryListingForTestInternal(imageService).DiscoveredUpdateRows(ctx, containers, map[string]struct{}{}, iconcatalog.DefaultCatalog)
+ rows := discoveryListingForTest(imageService).DiscoveredUpdateRows(ctx, containers, map[string]struct{}{}, iconcatalog.DefaultCatalog)
require.Len(t, rows, 1, "replicas count once and a tag policy never inherits the digest check")
assert.Equal(t, "compose:media", rows[0].ID)
@@ -3927,7 +3926,7 @@ func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *t
// The tracked-project path resolves the same record through the runtime image ID.
service := &ProjectService{imageService: imageService}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
detail := projecttypes.Details{
ID: "tracked",
RuntimeServices: []projecttypes.RuntimeService{
@@ -3940,11 +3939,11 @@ func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *t
},
},
}
- service.enrichProjectUpdateInfoInternal(ctx, &detail)
+ service.enrichProjectUpdateInfo(ctx, &detail)
require.True(t, detail.UpdateInfo.HasUpdate)
assert.Equal(t, []string{"nginx:latest"}, detail.UpdateInfo.UpdatedImageRefs)
detail.RuntimeServices[0].ImageID = ""
- service.enrichProjectUpdateInfoInternal(ctx, &detail)
+ service.enrichProjectUpdateInfo(ctx, &detail)
require.False(t, detail.UpdateInfo.HasUpdate, "a missing runtime image ID inherits nothing")
}
@@ -3952,7 +3951,7 @@ func TestProjectService_ListProjects_FiltersArchivedProjects(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
@@ -4014,7 +4013,7 @@ func TestProjectService_ArchiveProject_RequiresStoppedProject(t *testing.T) {
ctx := t.Context()
projectsRoot := t.TempDir()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
@@ -4028,7 +4027,7 @@ func TestProjectService_ArchiveProject_RequiresStoppedProject(t *testing.T) {
Status: ProjectStatusStopped,
}).Error)
- configureProjectRuntimeDockerInternal(t, []container.Summary{
+ configureProjectRuntimeDocker(t, []container.Summary{
{
ID: "app-container",
Names: []string{"/running-demo-app-1"},
@@ -4060,7 +4059,7 @@ func TestProjectService_ArchiveProject_TogglesArchiveFlag(t *testing.T) {
ctx := t.Context()
projectsRoot := t.TempDir()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
@@ -4073,7 +4072,7 @@ func TestProjectService_ArchiveProject_TogglesArchiveFlag(t *testing.T) {
Status: ProjectStatusStopped,
}).Error)
- configureProjectRuntimeDockerInternal(t, nil)
+ configureProjectRuntimeDocker(t, nil)
svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
user := usertypes.Actor{ID: "user-1", Username: "tester"}
@@ -4096,7 +4095,7 @@ func TestProjectService_ArchiveProject_LiveVerificationErrorPolicy(t *testing.T)
ctx := t.Context()
projectsRoot := t.TempDir()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
@@ -4146,7 +4145,7 @@ func TestProjectService_ProjectListRows_PersistsInferredServiceCount(t *testing.
require.NoError(t, db.Create(&inferred).Error)
require.NoError(t, db.Create(&known).Error)
service := &ProjectService{db: db}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
containers := []container.Summary{
{ID: "c1", State: "running", Names: []string{"/inferred-web"}, Labels: map[string]string{
@@ -4162,7 +4161,7 @@ func TestProjectService_ProjectListRows_PersistsInferredServiceCount(t *testing.
service.listing = listing.New(func(context.Context) ([]container.Summary, error) { return containers, nil }, nil, nil)
snapshot := service.listing.Snapshot(t.Context())
- rows := service.projectListRowsInternal(t.Context(), projectsDir, []Project{inferred, known}, snapshot)
+ rows := service.projectListRows(t.Context(), projectsDir, []Project{inferred, known}, snapshot)
require.Len(t, rows, 2)
require.Equal(t, 2, rows[0].ServiceCount)
require.Equal(t, 4, rows[1].ServiceCount)
@@ -4182,7 +4181,7 @@ func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSe
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4200,7 +4199,7 @@ func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSe
}
svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- configureProjectRuntimeDockerInternal(t, nil)
+ configureProjectRuntimeDocker(t, nil)
items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
Filters: map[string]string{
@@ -4219,7 +4218,7 @@ func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSe
func TestProjectService_DeployProject_StopsOnBuildPreparationError(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4254,7 +4253,7 @@ func TestProjectService_DeployProject_StopsOnBuildPreparationError(t *testing.T)
func TestProjectService_DeployProject_BuildsGeneratedImageWithoutPull(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4290,7 +4289,7 @@ func TestProjectService_SyncProjectsFromFileSystem_IgnoresSymlinkedProjectDirsWh
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4316,7 +4315,7 @@ func TestProjectService_SyncProjectsFromFileSystem_DetectsSymlinkedProjectDirsWh
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4338,39 +4337,11 @@ func TestProjectService_SyncProjectsFromFileSystem_DetectsSymlinkedProjectDirsWh
assert.Equal(t, linkPath, items[0].Path)
}
-func TestProjectService_CountProjectFolders_RespectsFollowProjectSymlinks(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := t.Context()
-
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "regular")
- linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
- require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
- count, err := svc.countProjectFolders(ctx)
- require.NoError(t, err)
- assert.Equal(t, 1, count)
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
- count, err = svc.countProjectFolders(ctx)
- require.NoError(t, err)
- assert.Equal(t, 2, count)
-}
-
func TestProjectService_SyncProjectsFromFileSystem_DiscoversNestedProjectsAndRelativePaths(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4403,7 +4374,7 @@ func TestProjectService_SyncProjectsFromFileSystem_RespectsConfiguredScanMaxDept
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4427,7 +4398,7 @@ func TestProjectService_ListProjects_LoadsProjectIconFromGlobalEnvInIncludedMeta
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4474,53 +4445,11 @@ services:
assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconDarkURL)
}
-func TestProjectService_CountProjectFolders_RecursivelyCountsNestedProjects(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := t.Context()
-
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
- createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project2"))
- createComposeProjectDir(t, projectsRoot, "project2")
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
-
- count, err := svc.countProjectFolders(ctx)
- require.NoError(t, err)
- assert.Equal(t, 3, count)
-}
-
-func TestProjectService_CountProjectFolders_RespectsConfiguredScanMaxDepth(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := t.Context()
-
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "project1")
- createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
-
- count, err := svc.countProjectFolders(ctx)
- require.NoError(t, err)
- assert.Equal(t, 1, count)
-}
-
func TestProjectService_SyncProjectsFromFileSystem_RemovesDeletedNestedProject(t *testing.T) {
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4551,7 +4480,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PrunesLeakedScratchRow(t *tes
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4581,7 +4510,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectsWhenDirector
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
// An existing-but-empty projects directory simulates a mis-mapped or unmounted
@@ -4616,7 +4545,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectWithAmbiguous
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4652,7 +4581,7 @@ func TestProjectService_SyncProjectsFromFileSystem_RemovesProjectsBeyondReducedS
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4698,7 +4627,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PreservesDBRecordsWhenDirecto
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4747,7 +4676,7 @@ func TestProjectService_SyncProjectsFromFileSystem_DiscoversReadableProjectsDesp
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4789,7 +4718,7 @@ func TestProjectService_SyncProjectsFromFileSystem_DiscoversReadableProjectsDesp
}
assert.True(t, foundReadableSibling, "readable sibling project must still be discovered")
- // evaluateProjectPathErrorInternal only prunes on os.IsNotExist; a permission-denied
+ // evaluateProjectCleanup only prunes on os.IsNotExist; a permission-denied
// stat falls into the "keep the record" branch, so the stranded record must survive.
assert.True(t, foundStrandedRecord, "DB record under the unreadable subtree must not be pruned by a permission-denied stat")
}
@@ -4798,7 +4727,7 @@ func TestProjectService_SyncProjectsFromFileSystem_AllowsDuplicateLeafDirectorie
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4826,7 +4755,7 @@ func TestProjectService_SyncProjectsFromFileSystem_DetectsNestedSymlinkedProject
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4857,7 +4786,7 @@ func TestProjectService_SyncProjectsFromFileSystem_RemovesSymlinkedProjectsWhenD
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4891,7 +4820,7 @@ func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnCompos
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4918,7 +4847,7 @@ func TestProjectService_SyncProjectsFromFileSystem_AlignsNameToEffectiveComposeN
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4947,7 +4876,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PreservesValidCustomNameWitho
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -4980,7 +4909,7 @@ func TestProjectService_SyncProjectsFromFileSystem_PreservesGitOpsProjectWithCus
ctx := t.Context()
require.NoError(t, db.AutoMigrate(&GitOpsSync{}))
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -5030,7 +4959,7 @@ func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *tes
ctx := t.Context()
require.NoError(t, db.AutoMigrate(&GitOpsSync{}))
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -5066,7 +4995,7 @@ func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *tes
svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
- composeFromContent, envFromContent, _, err := svc.GetProjectContent(ctx, syncProjectID)
+ composeFromContent, envFromContent, _, err := svc.projectContent(ctx, syncProjectID)
require.NoError(t, err)
assert.Equal(t, composeContent, composeFromContent)
assert.Equal(t, "TZ=UTC\n", envFromContent)
@@ -5083,7 +5012,7 @@ func TestProjectService_UpdateProject_WritesThroughSymlinkedProjectPath(t *testi
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -5132,7 +5061,7 @@ func TestProjectService_UpdateProject_WritesThroughExternalEnvSymlink(t *testing
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -5190,7 +5119,7 @@ func TestProjectService_UpdateProject_RestoresExternalEnvSymlinkTargetWhenProjec
db := setupProjectTestDB(t)
ctx := t.Context()
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
projectsRoot := t.TempDir()
@@ -5261,14 +5190,14 @@ func createComposeProjectDir(t *testing.T, root, name string) string {
return projectPath
}
-func configureProjectRuntimeDockerInternal(t *testing.T, containers []container.Summary) {
+func configureProjectRuntimeDocker(t *testing.T, containers []container.Summary) {
t.Helper()
- server := newProjectRuntimeDockerServerInternal(t, containers)
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ server := newProjectRuntimeDockerServer(t, containers)
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
}
-func projectUpdatePreviewDirsInternal(t *testing.T, projectsDir string) []string {
+func projectUpdatePreviewDirs(t *testing.T, projectsDir string) []string {
t.Helper()
matches, err := filepath.Glob(filepath.Join(projectsDir, ".project-update-preview-*"))
@@ -5276,7 +5205,7 @@ func projectUpdatePreviewDirsInternal(t *testing.T, projectsDir string) []string
return matches
}
-func newProjectRuntimeDockerServerInternal(t *testing.T, containers []container.Summary) *httptest.Server {
+func newProjectRuntimeDockerServer(t *testing.T, containers []container.Summary) *httptest.Server {
t.Helper()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -5318,7 +5247,7 @@ func newProjectRuntimeDockerServerInternal(t *testing.T, containers []container.
return server
}
-func dockerHostFromProjectRuntimeServerURLInternal(t *testing.T, serverURL string) string {
+func dockerHostFromProjectRuntimeServerURL(t *testing.T, serverURL string) string {
t.Helper()
parsed, err := url.Parse(serverURL)
@@ -5524,7 +5453,7 @@ func TestProjectService_RecoverProjectRenameJournals_RelocatesTargetWhenBothPath
require.Equal(t, oldDir, *fromDB.DirName)
newName := "web"
- require.NoError(t, svc.applyProjectRenameIfNeeded(t.Context(), &fromDB, &newName, projectsDir))
+ require.NoError(t, svc.applyProjectRename(t.Context(), &fromDB, newName, projectsDir))
require.Equal(t, "web", fromDB.Name)
require.Equal(t, newPath, fromDB.Path)
require.DirExists(t, newPath)
@@ -5616,7 +5545,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsPreservedTargetJourna
t.Cleanup(server.Close)
kvService := kv.NewKVService(db)
- svc := NewProjectService(db, nil, nil, nil, &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}, nil, nil, nil, config.Load(), kvService, nil)
+ svc := NewProjectService(db, nil, nil, nil, &docker.DockerClientService{Client: newTestDockerClient(t, server)}, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
OldName: "nginx",
@@ -5722,7 +5651,7 @@ func TestProjectService_FinalizeProjectRenameAfterCommit_ClearsJournalAfterSourc
}
require.NoError(t, svc.updates.WriteJournal(ctx, journal, projecttypes.RenameJournalPhaseTargetsCopied))
- migration := &fakeProjectVolumeRenameMigrationInternal{}
+ migration := &fakeProjectVolumeRenameMigration{}
journalActive := true
projects.FinalizeRenameAfterCommit(ctx, svc.updates.Operations(), project.ID, migration, journal, &journalActive)
require.True(t, migration.commitCalled)
@@ -5763,7 +5692,7 @@ func TestProjectService_FinalizeProjectRenameAfterCommit_KeepsJournalWhenSourceC
}
require.NoError(t, svc.updates.WriteJournal(ctx, journal, projecttypes.RenameJournalPhaseTargetsCopied))
- migration := &fakeProjectVolumeRenameMigrationInternal{
+ migration := &fakeProjectVolumeRenameMigration{
commitErr: volumes.NewSourceCleanupError("nginx_data", errors.New("source cleanup failed")),
}
journalActive := true
@@ -5834,7 +5763,7 @@ func TestProjectService_RecoverProjectRenameJournals_KeepsJournalWhenDirectoryRo
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -5928,7 +5857,7 @@ func TestProjectService_RecoverProjectRenameJournals_CompletesCommittedVolumeJou
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6001,7 +5930,7 @@ func TestProjectService_RecoverProjectRenameJournals_RollsBackCommittedJournalWh
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6111,7 +6040,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalAfterDBRestore
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6251,7 +6180,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalWhenS
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6337,7 +6266,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalAndCl
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6420,7 +6349,7 @@ func TestProjectService_RecoverProjectRenameJournals_MarksSourceCleanupPendingWh
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6505,7 +6434,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsSourceCleanupPendingJ
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6604,7 +6533,7 @@ func TestProjectService_RecoverProjectRenameJournals_RollsBackSourceCleanupPendi
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6694,7 +6623,7 @@ func TestProjectService_RecoverProjectRenameJournals_KeepsSourceCleanupPendingJo
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6830,7 +6759,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsMissingPathJournalWhe
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6904,7 +6833,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackSo
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -6983,7 +6912,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackTa
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -7068,7 +6997,7 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPres
require.NoError(t, db.Create(project).Error)
kvService := kv.NewKVService(db)
- dockerService := &docker.DockerClientService{Client: newTestDockerClientInternal(t, server)}
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
svc := NewProjectService(db, nil, nil, nil, dockerService, nil, nil, nil, config.Load(), kvService, nil)
journal := projecttypes.RenameJournal{
ProjectID: project.ID,
@@ -7102,16 +7031,16 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPres
require.NoDirExists(t, newPath)
}
-func TestProjectPathMapperUsesCurrentSettingsInternal(t *testing.T) {
+func TestProjectPathMapperUsesCurrentSettings(t *testing.T) {
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), db)
+ settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
require.NoError(t, err)
service := &ProjectService{settingsService: settingsService}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
containerDir := t.TempDir()
for _, hostDir := range []string{t.TempDir(), t.TempDir()} {
require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", containerDir+":"+hostDir))
- mapper := service.projectPathMapperInternal(t.Context())
+ mapper := service.projectPathMapper(t.Context())
require.NotNil(t, mapper)
mapped, _, containerToHostErr := mapper.ContainerToHost(filepath.Join(containerDir, "data"))
require.NoError(t, containerToHostErr)
@@ -7232,7 +7161,7 @@ func TestUpdateProjectServiceImagesRejectsManagedOrArchived(t *testing.T) {
}
require.NoError(t, db.Create(&proj).Error)
service := &ProjectService{db: db}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
err := service.UpdateProjectServiceImages(t.Context(), proj.ID, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: "app:1.0.0", TargetRef: "app:1.1.0"}}, usertypes.Actor{})
require.Error(t, err)
if name == "archived" {
@@ -7244,13 +7173,13 @@ func TestUpdateProjectServiceImagesRejectsManagedOrArchived(t *testing.T) {
}
}
-type serviceImageCoordinatorInternal struct {
+type serviceImageCoordinator struct {
projecttypes.ComposeCoordinator
requests []projecttypes.ComposeServiceUpdate
err error
}
-func (c *serviceImageCoordinatorInternal) UpdateServices(_ context.Context, request projecttypes.ComposeServiceUpdate) error {
+func (c *serviceImageCoordinator) UpdateServices(_ context.Context, request projecttypes.ComposeServiceUpdate) error {
c.requests = append(c.requests, request)
return c.err
}
@@ -7260,7 +7189,7 @@ func TestUpdateProjectServiceImagesPersistsBeforeDeploymentAndRetries(t *testing
db := setupProjectTestDB(t)
directory := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", directory)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
projectPath := createComposeProjectDir(t, directory, "image-tags")
@@ -7271,9 +7200,9 @@ func TestUpdateProjectServiceImagesPersistsBeforeDeploymentAndRetries(t *testing
proj := &Project{ID: "image-tags", Name: "image-tags", Path: projectPath, Status: ProjectStatusRunning}
require.NoError(t, db.Create(proj).Error)
deploymentError := errors.New("deployment failed after source persistence")
- coordinator := &serviceImageCoordinatorInternal{err: deploymentError}
+ coordinator := &serviceImageCoordinator{err: deploymentError}
service := &ProjectService{db: db, settingsService: settingsService, eventService: event.NewEventService(db, nil, nil), composeCoordinator: coordinator}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
changes := map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}
for range 2 {
updateProjectServiceImagesErr := service.UpdateProjectServiceImages(ctx, proj.ID, changes, usertypes.SystemUser)
@@ -7300,7 +7229,7 @@ func TestUpdateProjectServiceImagesRejectsOverrideBeforeWriting(t *testing.T) {
db := setupProjectTestDB(t)
directory := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", directory)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
projectPath := createComposeProjectDir(t, directory, "image-overrides")
@@ -7311,7 +7240,7 @@ func TestUpdateProjectServiceImagesRejectsOverrideBeforeWriting(t *testing.T) {
proj := &Project{ID: "image-overrides", Name: "image-overrides", Path: projectPath}
require.NoError(t, db.Create(proj).Error)
service := &ProjectService{db: db, settingsService: settingsService}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
err = service.UpdateProjectServiceImages(ctx, proj.ID, map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}, usertypes.SystemUser)
require.ErrorContains(t, err, "overrides")
content, err := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
@@ -7370,26 +7299,26 @@ func TestDiscoveredProjectTagUpdatesRemainScoped(t *testing.T) {
{ID: "second", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{"com.docker.compose.project": "second-project", "com.docker.compose.service": "web"}},
}
imageSvc := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
- rows := discoveryListingForTestInternal(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
+ rows := discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
require.Len(t, rows, 1)
require.Equal(t, "first-project", rows[0].Name)
require.True(t, rows[0].UpdateInfo.HasUpdate)
require.Equal(t, target, rows[0].UpdateInfo.UpdateInfoByRef["example:3.1.0"].LatestVersion)
service := &ProjectService{imageService: image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
detail := projecttypes.Details{ID: "tracked", RuntimeServices: []projecttypes.RuntimeService{{ContainerID: "first", Image: "example:3.1.0", ContainerLabels: tagLabels}}}
- service.enrichProjectUpdateInfoInternal(t.Context(), &detail)
+ service.enrichProjectUpdateInfo(t.Context(), &detail)
require.True(t, detail.UpdateInfo.HasUpdate)
require.Equal(t, target, detail.UpdateInfo.UpdateInfoByRef["example:3.1.0"].LatestVersion)
delete(containers[1].Labels, labels.LabelUpdateStrategy)
- rows = discoveryListingForTestInternal(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
+ rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
require.Empty(t, rows, "removing the strategy label falls back to digest checks")
detail.RuntimeServices[0].ContainerLabels = containers[1].Labels
- service.enrichProjectUpdateInfoInternal(t.Context(), &detail)
+ service.enrichProjectUpdateInfo(t.Context(), &detail)
require.False(t, detail.UpdateInfo.HasUpdate, "an undeclared strategy no longer inherits a tag record")
// Turning off automatic installation keeps the check current (#3532).
containers[1].Labels = map[string]string{labels.LabelUpdateStrategy: "tag", labels.LabelUpdater: "off", "com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}
- rows = discoveryListingForTestInternal(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
+ rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
require.Len(t, rows, 1, "updater=false containers keep their check results")
for _, policy := range []map[string]string{
{
@@ -7411,10 +7340,10 @@ func TestDiscoveredProjectTagUpdatesRemainScoped(t *testing.T) {
current := map[string]string{"com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}
maps.Copy(current, policy)
containers[1].Labels = current
- rows = discoveryListingForTestInternal(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
+ rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
require.Empty(t, rows, "stale records must not mark discovered projects updated")
detail.RuntimeServices[0].ContainerLabels = current
- service.enrichProjectUpdateInfoInternal(t.Context(), &detail)
+ service.enrichProjectUpdateInfo(t.Context(), &detail)
require.False(t, detail.UpdateInfo.HasUpdate, "runtime fallback must not apply a stale policy")
}
}
@@ -7462,7 +7391,7 @@ func TestProjectTagSummaryDoesNotMutateSharedReferenceResults(t *testing.T) {
func TestCountProjectsWithPendingTagUpdatesUsesRuntimeContainers(t *testing.T) {
db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), db)
+ settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
require.NoError(t, err)
projectRecords := []Project{
{Name: "first", Path: "first", ImageRefsJSON: `["example:3.1.0"]`},
@@ -7488,7 +7417,7 @@ func TestCountProjectsWithPendingTagUpdatesUsesRuntimeContainers(t *testing.T) {
).Error,
)
service := &ProjectService{db: db, settingsService: settingsService, imageService: image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
containers := []container.Summary{
{
ID: "first-container",
@@ -7537,12 +7466,12 @@ func TestCountProjectsWithPendingTagUpdatesUsesRuntimeContainers(t *testing.T) {
require.Zero(t, count, "disabling update checks on every replica suppresses the project")
}
-type serviceTagTransportInternal struct {
+type serviceTagTransport struct {
tags []string
calls int
}
-func (s *serviceTagTransportInternal) RoundTrip(request *http.Request) (*http.Response, error) {
+func (s *serviceTagTransport) RoundTrip(request *http.Request) (*http.Response, error) {
// The /v2/ version check precedes every listing and is not a tag call.
if request.URL.Path == "/v2/" {
return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: http.NoBody, Request: request}, nil
@@ -7579,7 +7508,7 @@ func TestProjectServiceManualUpdateDiscoversTags(t *testing.T) {
directory := t.TempDir()
require.NoError(t, db.AutoMigrate(&registry.ContainerRegistry{}))
t.Setenv("PROJECTS_DIRECTORY", directory)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
path := createComposeProjectDir(t, directory, "manual-tag")
@@ -7597,11 +7526,11 @@ func TestProjectServiceManualUpdateDiscoversTags(t *testing.T) {
proj := &Project{ID: "manual-tag", Name: "manual-tag", Path: path, Status: ProjectStatusRunning}
require.NoError(t, db.Create(proj).Error)
deploymentError := errors.New("deployment reached")
- coordinator := &serviceImageCoordinatorInternal{err: deploymentError}
- transport := &serviceTagTransportInternal{tags: tt.tags}
+ coordinator := &serviceImageCoordinator{err: deploymentError}
+ transport := &serviceTagTransport{tags: tt.tags}
registryService := registry.NewContainerRegistryService(db, nil, nil, nil, &http.Client{Transport: transport})
service := &ProjectService{db: db, settingsService: settingsService, eventService: event.NewEventService(db, nil, nil), composeCoordinator: coordinator, containerRegistryService: registryService}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
err = service.UpdateProjectServices(ctx, proj.ID, []string{"app", "selected-digest"}, usertypes.SystemUser, !tt.skipDiscovery)
require.ErrorIs(t, err, deploymentError)
require.Equal(t, tt.wantCalls, transport.calls)
@@ -7635,7 +7564,7 @@ func TestProjectServiceManualUpdateRejectsUnsafeTagPolicies(t *testing.T) {
serviceConfig := types.ServiceConfig{Image: "app:1.2.0", Labels: types.Labels{labels.LabelUpdateStrategy: "tag"}}
tt.change(&serviceConfig)
service := &ProjectService{}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
changes, err := service.updates.ImageChanges(t.Context(), &types.Project{Services: types.Services{"app": serviceConfig}}, false)
require.Error(t, err)
require.NotContains(t, err.Error(), "registry service unavailable")
@@ -7644,7 +7573,7 @@ func TestProjectServiceManualUpdateRejectsUnsafeTagPolicies(t *testing.T) {
}
local := types.ServiceConfig{Name: "app", Image: "app:1.2.0", Build: &types.BuildConfig{Context: "."}}
emptyService := &ProjectService{}
- emptyService.initChildrenInternal(nil, nil)
+ emptyService.initChildren(nil, nil)
changes, err := emptyService.updates.ImageChanges(t.Context(), &types.Project{Services: types.Services{"app": local}}, false)
require.NoError(t, err)
require.Empty(t, changes, "automatic inference must preserve local-build handling")
@@ -7683,7 +7612,7 @@ func TestStoppedProjectTagPolicyNeverInheritsSharedDigestCheck(t *testing.T) {
db := setupProjectTestDB(t)
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), db)
+ settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", projectsDir))
projectPath := createComposeProjectDir(t, projectsDir, "tag-stopped")
@@ -7711,7 +7640,7 @@ func TestStoppedProjectTagPolicyNeverInheritsSharedDigestCheck(t *testing.T) {
require.Equal(t, "unknown", detail.UpdateInfo.Status)
require.Nil(t, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo)
list := []projecttypes.Details{{ID: projectRecord.ID}}
- service.enrichProjectsWithUpdateInfoInternal(t.Context(), []Project{*projectRecord}, list, true, nil)
+ service.enrichProjectsWithUpdateInfo(t.Context(), []Project{*projectRecord}, list, true, nil)
require.Equal(t, "unknown", list[0].UpdateInfo.Status)
require.Nil(t, list[0].UpdateInfo.ServiceUpdates["app"].UpdateInfo)
target := "3.2.0"
@@ -7738,7 +7667,7 @@ func TestStoppedProjectTagPolicyNeverInheritsSharedDigestCheck(t *testing.T) {
require.NoError(t, err)
require.Equal(t, "has_update", detail.UpdateInfo.Status)
require.Equal(t, target, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo.LatestVersion)
- service.enrichProjectsWithUpdateInfoInternal(t.Context(), []Project{*projectRecord}, list, true, nil)
+ service.enrichProjectsWithUpdateInfo(t.Context(), []Project{*projectRecord}, list, true, nil)
require.Equal(t, "has_update", list[0].UpdateInfo.Status)
count, err := service.CountProjectsWithPendingUpdates(t.Context(), []container.Summary{})
require.NoError(t, err)
@@ -7761,7 +7690,7 @@ func TestConfiguredProjectUsesScheduledRuntimeChecks(t *testing.T) {
db := setupProjectTestDB(t)
directory := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", directory)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
path := createComposeProjectDir(t, directory, "scheduled-project")
@@ -7801,12 +7730,12 @@ func TestConfiguredProjectUsesScheduledRuntimeChecks(t *testing.T) {
runtimeLabels[labels.LabelUpdateConstraint] = cmp.Or(tt.runtimeConstraint, runtimeLabels[labels.LabelUpdateConstraint])
runtimeServices := []projecttypes.RuntimeService{{Name: "web", ContainerID: "scheduled", Image: "example:3.1.0", ContainerLabels: runtimeLabels}}
service := &ProjectService{db: db, settingsService: settingsService, imageService: image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
detail := projecttypes.Details{ID: proj.ID, Services: []types.ServiceConfig{{Name: "web", Image: tt.sourceRef, Labels: sourceLabels}}, RuntimeServices: runtimeServices}
- service.enrichProjectUpdateInfoInternal(ctx, &detail)
+ service.enrichProjectUpdateInfo(ctx, &detail)
require.Equal(t, tt.wantUpdate, detail.UpdateInfo.HasUpdate)
list := []projecttypes.Details{{ID: proj.ID, RuntimeServices: runtimeServices}}
- service.enrichProjectsWithUpdateInfoInternal(ctx, []Project{proj}, list, true, nil)
+ service.enrichProjectsWithUpdateInfo(ctx, []Project{proj}, list, true, nil)
require.Equal(t, tt.wantUpdate, list[0].UpdateInfo.HasUpdate)
for _, info := range []*projecttypes.UpdateInfo{detail.UpdateInfo, list[0].UpdateInfo} {
if tt.wantUpdate {
@@ -7883,7 +7812,7 @@ func TestConfiguredProjectAggregatesReplicaAndPreviewChecks(t *testing.T) {
require.True(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)
}
-func TestPrepareProjectBindDirectoriesInternal(t *testing.T) {
+func TestPrepareProjectBindDirectories(t *testing.T) {
t.Parallel()
newProject := func(volumes ...types.ServiceVolumeConfig) *types.Project {
@@ -7994,7 +7923,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfPermissionLockedEnv(t
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
eventService := event.NewEventService(db, nil, nil)
@@ -8037,7 +7966,7 @@ func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfPermissionLockedEnv(t
assert.Equal(t, "FOO=locked\n", string(envBytes))
}
-func TestPrepareProjectBindDirectoriesInternal_PermissionFailure(t *testing.T) {
+func TestPrepareProjectBindDirectories_PermissionFailure(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
@@ -8121,7 +8050,7 @@ func TestPrepareProjectBindDirectoriesInternal_PermissionFailure(t *testing.T) {
}
}
-func newEnvDirectoryProjectInternal(t *testing.T, id string) (*ProjectService, *Project, string, context.Context) {
+func newEnvDirectoryProject(t *testing.T, id string) (*ProjectService, *Project, string, context.Context) {
t.Helper()
db := setupProjectTestDB(t)
@@ -8130,7 +8059,7 @@ func newEnvDirectoryProjectInternal(t *testing.T, id string) (*ProjectService, *
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
@@ -8153,7 +8082,7 @@ func newEnvDirectoryProjectInternal(t *testing.T, id string) (*ProjectService, *
return svc, project, envDir, ctx
}
-func assertEnvDirectoryIntactInternal(t *testing.T, envDir string) {
+func assertEnvDirectoryIntact(t *testing.T, envDir string) {
t.Helper()
info, err := os.Stat(envDir)
require.NoError(t, err)
@@ -8165,7 +8094,7 @@ func TestProjectService_EnvDirectory_SyncAndDetails(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
- svc, project, envDir, ctx := newEnvDirectoryProjectInternal(t, "env-dir-scan")
+ svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-scan")
require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
all, err := svc.ListAllProjects(ctx)
@@ -8178,14 +8107,14 @@ func TestProjectService_EnvDirectory_SyncAndDetails(t *testing.T) {
assert.Empty(t, details.EnvContent)
assert.Contains(t, details.ComposeContent, "nginx:alpine")
- assertEnvDirectoryIntactInternal(t, envDir)
+ assertEnvDirectoryIntact(t, envDir)
}
func TestProjectService_EnvDirectory_UpdateCompose(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
- svc, project, envDir, ctx := newEnvDirectoryProjectInternal(t, "env-dir-update")
+ svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-update")
_, err := svc.UpdateProject(ctx, project.ID, nil, new("services:\n app:\n image: nginx:1.27-alpine\n"), nil, nil, usertypes.Actor{ID: "u1", Username: "tester"})
require.NoError(t, err)
@@ -8193,14 +8122,14 @@ func TestProjectService_EnvDirectory_UpdateCompose(t *testing.T) {
composeBytes, err := os.ReadFile(filepath.Join(project.Path, "compose.yaml"))
require.NoError(t, err)
assert.Contains(t, string(composeBytes), "nginx:1.27-alpine")
- assertEnvDirectoryIntactInternal(t, envDir)
+ assertEnvDirectoryIntact(t, envDir)
}
func TestProjectService_EnvDirectory_GitSync(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
- svc, project, envDir, ctx := newEnvDirectoryProjectInternal(t, "env-dir-git")
+ svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-git")
_, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:1.27-alpine\n", new("FOO=fromgit\n"), nil, "", usertypes.Actor{ID: "u1", Username: "tester"})
require.NoError(t, err)
@@ -8208,25 +8137,25 @@ func TestProjectService_EnvDirectory_GitSync(t *testing.T) {
composeBytes, err := os.ReadFile(filepath.Join(project.Path, "compose.yaml"))
require.NoError(t, err)
assert.Contains(t, string(composeBytes), "nginx:1.27-alpine")
- assertEnvDirectoryIntactInternal(t, envDir)
+ assertEnvDirectoryIntact(t, envDir)
}
func TestProjectService_EnvDirectory_EnvSaveFails(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
- svc, project, envDir, ctx := newEnvDirectoryProjectInternal(t, "env-dir-save")
+ svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-save")
_, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("FOO=bar\n"), nil, usertypes.Actor{ID: "u1", Username: "tester"})
require.ErrorContains(t, err, ".env is a directory")
- assertEnvDirectoryIntactInternal(t, envDir)
+ assertEnvDirectoryIntact(t, envDir)
}
func TestProjectService_OverrideEnvDirectory_EnvSaveFails(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("requires Unix permission semantics")
}
- svc, project, envDir, ctx := newEnvDirectoryProjectInternal(t, "override-dir-save")
+ svc, project, envDir, ctx := newEnvDirectoryProject(t, "override-dir-save")
require.NoError(t, os.RemoveAll(envDir))
require.NoError(t, os.WriteFile(filepath.Join(project.Path, ".env.git"), []byte("FOO=git\n"), 0o644))
overrideDir := filepath.Join(project.Path, "project.env")
@@ -8239,7 +8168,7 @@ func TestProjectService_OverrideEnvDirectory_EnvSaveFails(t *testing.T) {
assert.True(t, info.IsDir())
}
-func TestComposeFileInternal(t *testing.T) {
+func TestComposeFile(t *testing.T) {
t.Parallel()
const resolved = "/projects/app/compose.yaml"
@@ -8253,7 +8182,7 @@ func TestComposeFileInternal(t *testing.T) {
tests := []struct {
name string
- env *projectMetadataEnvInternal
+ env *projectMetadataEnv
projectID string
// results is returned by resolve in order; the last entry repeats.
results []error
@@ -8261,7 +8190,7 @@ func TestComposeFileInternal(t *testing.T) {
}{
{
name: "caches success",
- env: &projectMetadataEnvInternal{},
+ env: &projectMetadataEnv{},
projectID: "p1",
results: []error{nil},
calls: []call{
@@ -8271,7 +8200,7 @@ func TestComposeFileInternal(t *testing.T) {
},
{
name: "retries after failure then caches success",
- env: &projectMetadataEnvInternal{},
+ env: &projectMetadataEnv{},
projectID: "p1",
results: []error{transient, nil},
calls: []call{
@@ -8282,7 +8211,7 @@ func TestComposeFileInternal(t *testing.T) {
},
{
name: "repeated failures are never memoized",
- env: &projectMetadataEnvInternal{},
+ env: &projectMetadataEnv{},
projectID: "p1",
results: []error{transient},
calls: []call{
@@ -8302,7 +8231,7 @@ func TestComposeFileInternal(t *testing.T) {
},
{
name: "empty project ID resolves every call",
- env: &projectMetadataEnvInternal{},
+ env: &projectMetadataEnv{},
projectID: "",
results: []error{nil},
calls: []call{
@@ -8327,7 +8256,7 @@ func TestComposeFileInternal(t *testing.T) {
}
for i, want := range tt.calls {
- path, err := tt.env.composeFileInternal(tt.projectID, resolve)
+ path, err := tt.env.composeFile(tt.projectID, resolve)
if !errors.Is(err, want.wantErr) {
t.Fatalf("call %d: err = %v, want %v", i+1, err, want.wantErr)
}
@@ -8345,7 +8274,7 @@ func TestComposeFileInternal(t *testing.T) {
func TestProjectTags_ReconcilePreservesUIAndComposeOwnershipIsReadOnly(t *testing.T) {
db := setupProjectTestDB(t)
service := &ProjectService{db: db}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
ctx := t.Context()
projectModel := Project{
ID: "project-tags",
@@ -8361,7 +8290,7 @@ func TestProjectTags_ReconcilePreservesUIAndComposeOwnershipIsReadOnly(t *testin
require.NoError(t, err)
require.Equal(t, []projecttypes.Tag{{Name: "database", Color: projecttypes.TagColorPurple, Sources: []projecttypes.TagSource{projecttypes.TagSourceUI}}}, projectTags)
- require.NoError(t, service.reconcileComposeProjectTagsInternal(ctx, projectModel.ID, []projecttypes.TagOption{
+ require.NoError(t, service.reconcileComposeProjectTags(ctx, projectModel.ID, []projecttypes.TagOption{
{Name: "DATABASE", Color: projecttypes.TagColorBlue},
{Name: "maintenance-window", Color: projecttypes.TagColorOrange},
}))
@@ -8377,7 +8306,7 @@ func TestProjectTags_ReconcilePreservesUIAndComposeOwnershipIsReadOnly(t *testin
_, err = service.UpdateProjectTag(ctx, projectModel.ID, "maintenance-window", projecttypes.TagColorBlue, true, usertypes.Actor{})
require.ErrorIs(t, err, tags.ErrComposeTagReadOnly)
- require.NoError(t, service.reconcileComposeProjectTagsInternal(ctx, projectModel.ID, nil))
+ require.NoError(t, service.reconcileComposeProjectTags(ctx, projectModel.ID, nil))
projectTags, err = service.UpdateProjectTag(ctx, projectModel.ID, "database", "", false, usertypes.Actor{})
require.NoError(t, err)
require.Empty(t, projectTags)
@@ -8405,11 +8334,13 @@ func TestProjectTags_FilterUsesExactORNames(t *testing.T) {
require.ElementsMatch(t, []string{"one", "two"}, []string{result[0].ID, result[1].ID})
require.NotContains(t, []string{result[0].ID, result[1].ID}, "three")
- result = nil
- err = listing.ApplyProjectSearchDBFilter(db.WithContext(ctx).Model(&Project{}), "MAINT").Find(&result).Error
+ settingsService, err := newSettingsServiceForTest(t, ctx, db)
+ require.NoError(t, err)
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load(), nil, nil)
+ items, _, err := svc.ListProjects(ctx, pagination.QueryParams{Search: "MAINT", Limit: -1})
require.NoError(t, err)
- require.Len(t, result, 1)
- require.Equal(t, "two", result[0].ID)
+ require.Len(t, items, 1)
+ require.Equal(t, "two", items[0].ID)
}
func setupLifecycleTestDB(t *testing.T) *database.DB {
@@ -8519,7 +8450,7 @@ func TestParseLifecycleExtraMountsText_RejectsInvalidMode(t *testing.T) {
func TestRunPreDeploy_NilProject(t *testing.T) {
db := setupLifecycleTestDB(t)
svc, _ := newLifecycleTestService(t, db)
- require.NoError(t, svc.RunPreDeploy(t.Context(), nil, usertypes.Actor{}))
+ require.NoError(t, svc.runPreDeploy(t.Context(), nil, usertypes.Actor{}))
}
func TestRunPreDeploy_ProjectNotGitOpsManaged(t *testing.T) {
@@ -8532,17 +8463,68 @@ func TestRunPreDeploy_ProjectNotGitOpsManaged(t *testing.T) {
Path: t.TempDir(),
GitOpsManagedBy: nil,
}
- require.NoError(t, svc.RunPreDeploy(t.Context(), project, usertypes.Actor{}))
+ require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
+
+ // A stale marker without a sync row is treated as unmanaged.
+ project.ID = "nonexistent"
+ project.GitOpsManagedBy = new("missing-sync")
+ require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
}
-func TestRunPreDeploy_KillSwitchDisabled(t *testing.T) {
+func TestRunPreDeploy_KillSwitchAndLastRunState(t *testing.T) {
db := setupLifecycleTestDB(t)
- svc, _ := newLifecycleTestService(t, db)
+ settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
+ require.NoError(t, err)
+
+ var exitCode atomic.Int64
+ // Handlers run on server goroutines, so failures use assert rather than require.
+ writeFrame := func(w io.Writer, stream stdcopy.StdType, payload string) error {
+ header := []byte{byte(stream), 0, 0, 0}
+ if _, writeErr := w.Write(binary.BigEndian.AppendUint32(header, uint32(len(payload)))); writeErr != nil {
+ return fmt.Errorf("write stream %d frame header: %w", stream, writeErr)
+ }
+ if _, writeErr := io.WriteString(w, payload); writeErr != nil {
+ return fmt.Errorf("write stream %d frame payload: %w", stream, writeErr)
+ }
+ return nil
+ }
+ dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/images/alpine:latest/json"):
+ w.Header().Set("Content-Type", "application/json")
+ _, writeErr := io.WriteString(w, `{"Id":"sha256:runner"}`)
+ assert.NoError(t, writeErr, "write image inspect response")
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/create"):
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusCreated)
+ _, writeErr := io.WriteString(w, `{"Id":"hook-1"}`)
+ assert.NoError(t, writeErr, "write container create response")
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/hook-1/start"):
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/hook-1/logs"):
+ w.Header().Set("Content-Type", "application/vnd.docker.multiplexed-stream")
+ if !assert.NoError(t, writeFrame(w, stdcopy.Stdout, "hello\n"), "write stdout log frame") {
+ return
+ }
+ assert.NoError(t, writeFrame(w, stdcopy.Stderr, "boom\n"), "write stderr log frame")
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/hook-1/wait"):
+ w.Header().Set("Content-Type", "application/json")
+ _, writeErr := fmt.Fprintf(w, `{"StatusCode":%d}`, exitCode.Load())
+ assert.NoError(t, writeErr, "write container wait response")
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/containers/hook-1"):
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(dockerServer.Close)
+ dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
+ svc := NewLifecycleService(db, settingsService, event.NewEventService(db, nil, nil), dockerService, nil)
syncID := "sync-1"
project := &Project{
Name: "demo",
- Path: t.TempDir(),
+ Path: writeLifecycleProjectDirWithScript(t, "pre-deploy.sh", "echo hi\n"),
GitOpsManagedBy: &syncID,
}
project.ID = "proj-1"
@@ -8565,7 +8547,35 @@ func TestRunPreDeploy_KillSwitchDisabled(t *testing.T) {
sync.ID = syncID
require.NoError(t, db.Create(sync).Error)
- require.NoError(t, svc.RunPreDeploy(t.Context(), project, usertypes.Actor{}))
+ loadSync := func() GitOpsSync {
+ var stored GitOpsSync
+ require.NoError(t, db.First(&stored, "id = ?", syncID).Error)
+ return stored
+ }
+
+ // The kill switch skips the hook and leaves no last-run state.
+ require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
+ assert.Nil(t, loadSync().PreDeployLastRunAt)
+
+ require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))
+ before := time.Now()
+ require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
+ stored := loadSync()
+ require.NotNil(t, stored.PreDeployLastRunAt)
+ assert.WithinRange(t, *stored.PreDeployLastRunAt, before, time.Now())
+ assert.Equal(t, "success", mo.PointerToOption(stored.PreDeployLastRunStatus).OrEmpty())
+ assert.Equal(t, "hello\n--- stderr ---\nboom", mo.PointerToOption(stored.PreDeployLastRunOutput).OrEmpty())
+
+ exitCode.Store(3)
+ before = time.Now()
+ err = svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "exited with status 3")
+ stored = loadSync()
+ require.NotNil(t, stored.PreDeployLastRunAt)
+ assert.WithinRange(t, *stored.PreDeployLastRunAt, before, time.Now())
+ assert.Equal(t, "failed", mo.PointerToOption(stored.PreDeployLastRunStatus).OrEmpty())
+ assert.Equal(t, "hello\n--- stderr ---\nboom", mo.PointerToOption(stored.PreDeployLastRunOutput).OrEmpty())
}
func TestRunPreDeploy_NoScriptConfigured(t *testing.T) {
@@ -8595,7 +8605,7 @@ func TestRunPreDeploy_NoScriptConfigured(t *testing.T) {
sync.ID = syncID
require.NoError(t, db.Create(sync).Error)
- require.NoError(t, svc.RunPreDeploy(t.Context(), project, usertypes.Actor{}))
+ require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
}
func TestRunPreDeploy_MissingRunnerImage(t *testing.T) {
@@ -8629,22 +8639,11 @@ func TestRunPreDeploy_MissingRunnerImage(t *testing.T) {
sync.ID = syncID
require.NoError(t, db.Create(sync).Error)
- err := svc.RunPreDeploy(t.Context(), project, usertypes.Actor{})
+ err := svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
require.Error(t, err)
assert.Contains(t, err.Error(), "runner image")
}
-func TestResolveRunnerImage_UsesSettingDefault(t *testing.T) {
- db := setupLifecycleTestDB(t)
- svc, settingsService := newLifecycleTestService(t, db)
- require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleDefaultRunnerImage", "alpine:latest"))
-
- assert.Equal(t, "alpine:latest", svc.hooks.RunnerImage(t.Context(), nil))
-
- override := "debian:stable-slim"
- assert.Equal(t, override, svc.hooks.RunnerImage(t.Context(), &override))
-}
-
func TestRunPreDeploy_PathTraversalRejected(t *testing.T) {
db := setupLifecycleTestDB(t)
svc, settingsService := newLifecycleTestService(t, db)
@@ -8676,49 +8675,14 @@ func TestRunPreDeploy_PathTraversalRejected(t *testing.T) {
sync.ID = syncID
require.NoError(t, db.Create(sync).Error)
- err := svc.RunPreDeploy(t.Context(), project, usertypes.Actor{})
+ err := svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
require.Error(t, err)
assert.Contains(t, err.Error(), "script path")
}
-func TestLoadGitOpsSyncForProject_ReturnsNilWhenAbsent(t *testing.T) {
- db := setupLifecycleTestDB(t)
- sync, err := loadGitOpsSyncForProjectInternal(t.Context(), db, "nonexistent")
- require.NoError(t, err)
- assert.Nil(t, sync)
-}
-
-func TestPersistLastRun_UpdatesGitOpsSyncRow(t *testing.T) {
- db := setupLifecycleTestDB(t)
- svc, _ := newLifecycleTestService(t, db)
-
- sync := &GitOpsSync{
- Name: "demo-sync",
- EnvironmentID: "0",
- RepositoryID: "repo-1",
- Branch: "main",
- ComposePath: "docker-compose.yaml",
- TargetType: "project",
- ProjectName: "demo",
- }
- sync.ID = "sync-1"
- require.NoError(t, db.Create(sync).Error)
-
- now := time.Now().UTC().Truncate(time.Second)
- svc.persistLastRunInternal(t.Context(), sync.ID, lifecycle.LifecycleStatusSuccess, "all good", now)
-
- var got GitOpsSync
- require.NoError(t, db.Where("id = ?", sync.ID).First(&got).Error)
- require.NotNil(t, got.PreDeployLastRunAt)
- require.NotNil(t, got.PreDeployLastRunStatus)
- require.NotNil(t, got.PreDeployLastRunOutput)
- assert.Equal(t, lifecycle.LifecycleStatusSuccess, *got.PreDeployLastRunStatus)
- assert.Equal(t, "all good", *got.PreDeployLastRunOutput)
-}
-
-func discoveryListingForTestInternal(imageService *image.ImageService) *listing.Service {
+func discoveryListingForTest(imageService *image.ImageService) *listing.Service {
service := &ProjectService{imageService: imageService}
- service.initChildrenInternal(nil, nil)
+ service.initChildren(nil, nil)
return service.listing
}