Skip to content

Modern Docker Management, Designed for Everyone

perf(project): enrich filtered project lists after pagination (#4108)

Kyle Mendell92349aa97949
diff --git a/backend/internal/project/project.go b/backend/internal/project/project.go
index fffad092a..b3a8b5358 100644
--- a/backend/internal/project/project.go
+++ b/backend/internal/project/project.go
@@ -206,9 +206,10 @@ type projectMetadataEnvInternal struct {
autoInjectEnv bool
// settings is the snapshot shared by compose loads; nil resolves lazily.
settings *settings.Settings
- // gitOpsComposePaths maps the listed projects' GitOps sync IDs to their
- // configured compose paths. nil means the paths were not preloaded and are
- // queried per project; a missing key in a preloaded map means no sync row.
+ // gitOpsComposePaths maps preloaded GitOps sync IDs to their configured
+ // compose paths. Sync IDs that were preloaded but have no row map to "",
+ // which resolves the same way as a missing row; sync IDs absent from the
+ // map are queried per project.
gitOpsComposePaths map[string]string
// composeFiles memoizes successfully resolved compose files by project ID.
@@ -231,7 +232,14 @@ func (s *ProjectService) newProjectMetadataEnvInternal(ctx context.Context, proj
settings: s.settingsService.GetSettingsOrDefaults(ctx),
composeFiles: make(map[string]string, len(projectsList)),
}
+ s.preloadGitOpsComposePathsInternal(ctx, env, projectsList)
+ return env
+}
+// preloadGitOpsComposePathsInternal 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) {
syncIDs := make([]string, 0, len(projectsList))
for _, proj := range projectsList {
if id := gitOpsSyncIDInternal(&proj); id != "" {
@@ -239,20 +247,24 @@ func (s *ProjectService) newProjectMetadataEnvInternal(ctx context.Context, proj
}
}
if len(syncIDs) == 0 {
- return env
+ return
}
var syncRecords []GitOpsSync
if err := s.db.WithContext(ctx).Select("id", "compose_path").Where("id IN ?", syncIDs).Find(&syncRecords).Error; err != nil {
- // Leave the map nil so each project falls back to its own lookup and
- // surfaces the failure the same way it did before batching.
+ // Leave these IDs unloaded so each project falls back to its own lookup
+ // and surfaces the failure the same way it did before batching.
slog.WarnContext(ctx, "failed to batch resolve GitOps compose paths", "error", err)
- return env
+ return
+ }
+ if env.gitOpsComposePaths == nil {
+ env.gitOpsComposePaths = make(map[string]string, len(syncIDs))
+ }
+ for _, id := range syncIDs {
+ env.gitOpsComposePaths[id] = ""
}
- env.gitOpsComposePaths = make(map[string]string, len(syncRecords))
for _, record := range syncRecords {
env.gitOpsComposePaths[record.ID] = record.ComposePath
}
- return env
}
func gitOpsSyncIDInternal(proj *Project) string {
@@ -714,9 +726,10 @@ func (s *ProjectService) resolveProjectComposeFileUncachedInternal(ctx context.C
// 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 && env.gitOpsComposePaths != nil {
- composePath, found := env.gitOpsComposePaths[syncID]
- return composePath, found, nil
+ if env != nil {
+ if composePath, preloaded := env.gitOpsComposePaths[syncID]; preloaded {
+ return composePath, true, nil
+ }
}
var syncRecord GitOpsSync
err := s.db.WithContext(ctx).Select("compose_path").Where("id = ?", syncID).First(&syncRecord).Error
diff --git a/backend/internal/project/project_listing.go b/backend/internal/project/project_listing.go
index d32e62897..49b0b1456 100644
--- a/backend/internal/project/project_listing.go
+++ b/backend/internal/project/project_listing.go
@@ -9,6 +9,7 @@ import (
"maps"
"os"
"path/filepath"
+ "slices"
"strings"
"time"
@@ -107,11 +108,7 @@ func projectServiceInfoFromContainerInternal(ctx context.Context, c container.Su
health = new("starting")
}
- resolvedIcon := iconcatalog.Resolve(IconCatalogForContext(ctx), iconcatalog.FirstNonEmpty(
- projects.FindArcaneIconSet(c.Labels),
- meta.ServiceIconSets[svcName],
- meta.ProjectIcon,
- ))
+ resolvedIcon := resolveServiceIconInternal(IconCatalogForContext(ctx), c.Labels, svcName, meta)
return ProjectServiceInfo{
Name: svcName,
Image: c.Image,
@@ -127,6 +124,16 @@ func projectServiceInfoFromContainerInternal(ctx context.Context, c container.Su
}
}
+// resolveServiceIconInternal picks a service icon from its container labels,
+// then the compose metadata's per-service and project-level icon sets.
+func resolveServiceIconInternal(catalog string, containerLabels map[string]string, serviceName string, meta projects.ArcaneComposeMetadata) iconcatalog.ResolvedIconSet {
+ return iconcatalog.Resolve(catalog, iconcatalog.FirstNonEmpty(
+ projects.FindArcaneIconSet(containerLabels),
+ meta.ServiceIconSets[serviceName],
+ meta.ProjectIcon,
+ ))
+}
+
// 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) ([]ProjectServiceInfo, error) {
@@ -379,15 +386,50 @@ func (s *ProjectService) filterProjectsWithDerivedFiltersInternal(
return pagination.FilterResult[project.Details]{}, errors.WrapIf(err, "failed to list projects")
}
- env := s.newProjectMetadataEnvInternal(ctx, projectsArray)
- items := s.fetchProjectStatusConcurrently(ctx, projectsArray, env)
+ // 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)
+ snapshot := s.projectContainerSnapshotInternal(ctx)
+ items := s.projectListRowsInternal(ctx, env.projectsDirectory, projectsArray, snapshot)
if err := s.enrichProjectsWithTagsInternal(ctx, items); err != nil {
return pagination.FilterResult[project.Details]{}, err
}
- s.enrichProjectsWithUpdateInfoInternal(ctx, projectsArray, items, true, env)
- items = s.appendDiscoveredComposeProjectUpdatesInternal(ctx, params, projectsArray, items)
+ 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)
+ }
- return s.buildProjectDerivedPaginationConfigInternal().SearchOrderAndPaginate(items, withoutProjectDBFiltersInternal(params)), nil
+ result := s.buildProjectDerivedPaginationConfigInternal().SearchOrderAndPaginate(items, withoutProjectDBFiltersInternal(params))
+
+ byID := make(map[string]Project, len(projectsArray))
+ for _, proj := range projectsArray {
+ byID[proj.ID] = proj
+ }
+ pageProjects := make([]Project, 0, len(result.Items))
+ pageDetails := make([]project.Details, 0, len(result.Items))
+ pageIndexes := make([]int, 0, len(result.Items))
+ for i, item := range result.Items {
+ proj, tracked := byID[item.ID]
+ if !tracked {
+ // Discovered compose rows are built complete.
+ continue
+ }
+ pageProjects = append(pageProjects, proj)
+ pageDetails = append(pageDetails, item)
+ pageIndexes = append(pageIndexes, i)
+ }
+ if !updatesFiltered {
+ s.preloadGitOpsComposePathsInternal(ctx, env, pageProjects)
+ s.enrichProjectsWithUpdateInfoInternal(ctx, pageProjects, pageDetails, true, env)
+ }
+ s.applyProjectPresentationInternal(ctx, pageProjects, pageDetails, env)
+ for k, i := range pageIndexes {
+ result.Items[i] = pageDetails[k]
+ }
+ return result, nil
}
func withoutProjectDBFiltersInternal(params pagination.QueryParams) pagination.QueryParams {
@@ -404,19 +446,18 @@ func (s *ProjectService) appendDiscoveredComposeProjectUpdatesInternal(
params pagination.QueryParams,
projectsArray []Project,
items []project.Details,
+ snapshot projectContainerSnapshotInternal,
) []project.Details {
if !shouldIncludeDiscoveredComposeProjectUpdatesInternal(params) {
return items
}
-
- composeContainers, err := s.listGlobalComposeContainersInternal(ctx)
- if err != nil {
- slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", err)
+ if snapshot.err != nil {
+ slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", snapshot.err)
return items
}
knownProjectNames := s.buildKnownComposeProjectNameSetInternal(ctx, projectsArray, false)
- discovered := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, composeContainers, knownProjectNames, s.imageService, IconCatalogForContext(ctx))
+ discovered := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, snapshot.containers, knownProjectNames, s.imageService, IconCatalogForContext(ctx))
if len(discovered) == 0 {
return items
}
@@ -911,48 +952,39 @@ func (s *ProjectService) countDiscoveredComposeProjectUpdatesInternal(ctx contex
return len(buildDiscoveredComposeProjectUpdateRowsInternal(ctx, composeContainers, knownProjectNames, s.imageService, IconCatalogForContext(ctx)))
}
-// fetchProjectStatusConcurrently fetches live Docker status for multiple projects in parallel
-// Optimized to use a single Docker API call instead of N calls + N file reads.
-// 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) []project.Details {
- projectsDir := metaEnv.projectsDirectory
+// projectContainerSnapshotInternal is the compose container listing shared by
+// every row of one list request, grouped once by compose project name.
+type projectContainerSnapshotInternal struct {
+ containers []container.Summary
+ byProject map[string][]container.Summary
+ err error
+ currentContainerID string
+ currentContainerErr error
+}
- // 1. Fetch all compose containers in one go
+func (s *ProjectService) projectContainerSnapshotInternal(ctx context.Context) projectContainerSnapshotInternal {
containers, err := s.listGlobalComposeContainersInternal(ctx)
if err != nil {
slog.ErrorContext(ctx, "Failed to list global compose containers", "error", err)
- // Fallback: return basic info with unknown status
- metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)
- results := make([]project.Details, len(projectsList))
- for i, p := range projectsList {
- _ = mapper.MapStruct(p, &results[i])
- results[i].CreatedAt = p.CreatedAt.Format(time.RFC3339)
- results[i].UpdatedAt = p.UpdatedAt.Format(time.RFC3339)
- results[i].DirName = mo.PointerToOption(p.DirName).OrEmpty()
- results[i].RelativePath = getProjectRelativePathInternal(projectsDir, p.Path)
- results[i].GitOpsManagedBy = p.GitOpsManagedBy
- results[i].HasBuildDirective = p.BuildImageRefsJSON != nil && len(projects.ParseImageRefsJSON(*p.BuildImageRefsJSON)) > 0
- applyResolvedProjectIconInternal(&results[i], iconcatalog.Resolve(IconCatalogForContext(ctx), metas[i].ProjectIcon))
- results[i].URLs = metas[i].ProjectURLS
- results[i].ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, p.Path)
- results[i].Status = string(ProjectStatusUnknown)
- }
- return results
+ return projectContainerSnapshotInternal{err: err}
}
-
- // 2. Group containers by project name
- containersByProject := groupComposeContainersByProjectInternal(containers)
-
- // 3. Map to DTOs
- metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)
- results := make([]project.Details, len(projectsList))
currentContainerID, currentContainerErr := cgroup.CurrentContainerID()
- for i, p := range projectsList {
- results[i] = s.mapProjectToDto(ctx, projectsDir, p, containersByProject, currentContainerID, currentContainerErr, metas[i])
+ return projectContainerSnapshotInternal{
+ containers: containers,
+ byProject: groupComposeContainersByProjectInternal(containers),
+ currentContainerID: currentContainerID,
+ currentContainerErr: currentContainerErr,
}
+}
+// 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) []project.Details {
+ results := s.projectListRowsInternal(ctx, metaEnv.projectsDirectory, projectsList, s.projectContainerSnapshotInternal(ctx))
+ s.applyProjectPresentationInternal(ctx, projectsList, results, metaEnv)
return results
}
@@ -973,7 +1005,87 @@ func (s *ProjectService) resolveProjectMetadataConcurrentlyInternal(ctx context.
return metas
}
-func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir string, p Project, containersByProject map[string][]container.Summary, currentContainerID string, currentContainerErr error, meta projects.ArcaneComposeMetadata) project.Details {
+// applyProjectPresentationInternal resolves compose metadata for projectsList
+// and fills the fields filtering and sorting never read: project and service
+// icons, custom URLs, and the env access probe. details must align with
+// projectsList by index.
+func (s *ProjectService) applyProjectPresentationInternal(ctx context.Context, projectsList []Project, details []project.Details, metaEnv *projectMetadataEnvInternal) {
+ if len(projectsList) == 0 {
+ return
+ }
+ metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)
+ catalog := IconCatalogForContext(ctx)
+ for i := range projectsList {
+ resp := &details[i]
+ applyResolvedProjectIconInternal(resp, iconcatalog.Resolve(catalog, metas[i].ProjectIcon))
+ resp.URLs = metas[i].ProjectURLS
+ resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, metaEnv.projectsDirectory, projectsList[i].Path)
+ for k := range resp.RuntimeServices {
+ service := &resp.RuntimeServices[k]
+ icon := resolveServiceIconInternal(catalog, service.ContainerLabels, service.Name, metas[i])
+ service.IconLightURL, service.IconDarkURL = icon.IconLightURL, icon.IconDarkURL
+ }
+ }
+}
+
+func (s *ProjectService) projectListRowsInternal(ctx context.Context, projectsDir string, projectsList []Project, snapshot projectContainerSnapshotInternal) []project.Details {
+ rows := make([]project.Details, len(projectsList))
+ inferredCounts := make(map[string]int)
+ for i, p := range projectsList {
+ rows[i] = projectListRowInternal(ctx, projectsDir, p, snapshot)
+ if p.ServiceCount == 0 && rows[i].ServiceCount > 0 {
+ inferredCounts[p.ID] = rows[i].ServiceCount
+ }
+ }
+ s.persistInferredServiceCountsInternal(ctx, inferredCounts)
+ return rows
+}
+
+// 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 := make([]string, 0, len(counts))
+ for id := range counts {
+ ids = append(ids, id)
+ }
+ 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
+ }
+ }
+}
+
+// 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
+
+// projectListRowInternal 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 applyProjectPresentationInternal. When
+// the container listing failed the row reports an unknown status.
+func projectListRowInternal(ctx context.Context, projectsDir string, p Project, snapshot projectContainerSnapshotInternal) project.Details {
var resp project.Details
_ = mapper.MapStruct(p, &resp)
@@ -985,60 +1097,33 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir string
resp.RelativePath = getProjectRelativePathInternal(projectsDir, p.Path)
resp.GitOpsManagedBy = p.GitOpsManagedBy
resp.HasBuildDirective = p.BuildImageRefsJSON != nil && len(projects.ParseImageRefsJSON(*p.BuildImageRefsJSON)) > 0
- applyResolvedProjectIconInternal(&resp, iconcatalog.Resolve(IconCatalogForContext(ctx), meta.ProjectIcon))
- resp.URLs = meta.ProjectURLS
- resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, p.Path)
-
- projectContainers := lookupProjectContainersInternal(p, containersByProject)
+ // 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 {
+ resp.Status = string(ProjectStatusUnknown)
+ return resp
+ }
+ projectContainers := lookupProjectContainersInternal(p, snapshot.byProject)
services := make([]ProjectServiceInfo, 0, len(projectContainers))
-
for _, c := range projectContainers {
- service := projectServiceInfoFromContainerInternal(ctx, c, meta, currentContainerID, currentContainerErr)
+ service := projectServiceInfoFromContainerInternal(ctx, c, projects.ArcaneComposeMetadata{}, snapshot.currentContainerID, snapshot.currentContainerErr)
if service.RedeployDisabled {
resp.RedeployDisabled = true
}
services = append(services, service)
}
_, runningCount := getServiceCounts(services)
-
- // Convert to RuntimeServices
- runtimeServices := make([]project.RuntimeService, len(services))
- for k, s := range services {
- runtimeServices[k] = project.RuntimeService{
- Name: s.Name,
- Image: s.Image,
- Status: s.Status,
- ContainerID: s.ContainerID,
- ContainerLabels: s.Labels,
- ContainerName: s.ContainerName,
- Ports: s.Ports,
- Health: s.Health,
- IconLightURL: s.IconLightURL,
- IconDarkURL: s.IconDarkURL,
- ServiceConfig: s.ServiceConfig,
- RedeployDisabled: s.RedeployDisabled,
- }
- }
- resp.RuntimeServices = runtimeServices
-
- // Use DB service count as the source of truth for "Total Services"
- // since we are not parsing the YAML here.
- resp.ServiceCount = p.ServiceCount
+ resp.RuntimeServices = buildProjectRuntimeServicesInternal(services)
resp.RunningCount = runningCount
+ // Newly discovered projects have no persisted count yet. Infer it from the
+ // live containers; projectListRowsInternal persists the inferred value so
+ // SQL sorting and pagination on service_count see it on later requests.
if resp.ServiceCount == 0 && len(services) > 0 {
resp.ServiceCount = len(services)
- // Persist the inferred count so later list loads do not need compose parsing.
- go func(ctx context.Context, pid string, count int) {
- s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", pid).Update("service_count", count)
- }(context.WithoutCancel(ctx), p.ID, resp.ServiceCount)
}
- // For missing service count (e.g. newly discovered projects), skip the
- // expensive CountServicesFromCompose call which loads and parses the entire
- // compose project. The count will be populated the next time the project
- // detail endpoint is called or during the periodic filesystem sync.
-
// 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
diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.go
index f17b691b2..bcfac013c 100644
--- a/backend/internal/project/service_test.go
+++ b/backend/internal/project/service_test.go
@@ -4226,9 +4226,8 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- service := &ProjectService{}
tt.labels[composeapi.WorkingDirLabel] = projectPath
- details := service.mapProjectToDto(context.Background(), filepath.Dir(projectPath), proj, map[string][]container.Summary{
+ details := projectListRowInternal(context.Background(), filepath.Dir(projectPath), proj, projectContainerSnapshotInternal{byProject: map[string][]container.Summary{
"arcane": {
{
ID: tt.containerID,
@@ -4247,7 +4246,7 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(
},
},
},
- }, tt.currentContainerID, tt.currentErr, projects.ArcaneComposeMetadata{})
+ }, currentContainerID: tt.currentContainerID, currentContainerErr: tt.currentErr})
require.Equal(t, tt.wantProject, details.RedeployDisabled)
require.Len(t, details.RuntimeServices, 1)
@@ -4257,6 +4256,49 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(
}
}
+func TestProjectService_ProjectListRows_PersistsInferredServiceCount(t *testing.T) {
+ db := setupProjectTestDB(t)
+ projectsDir := t.TempDir()
+ projectPath := filepath.Join(projectsDir, "inferred")
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ inferred := Project{ID: "inferred", Name: "inferred", Path: projectPath, ServiceCount: 0}
+ known := Project{ID: "known", Name: "known", Path: filepath.Join(projectsDir, "known"), ServiceCount: 4}
+ require.NoError(t, db.Create(&inferred).Error)
+ require.NoError(t, db.Create(&known).Error)
+ service := &ProjectService{db: db}
+
+ snapshot := projectContainerSnapshotInternal{byProject: map[string][]container.Summary{
+ "inferred": {
+ {ID: "c1", State: "running", Names: []string{"/inferred-web"}, Labels: map[string]string{
+ composeapi.ProjectLabel: "inferred", composeapi.ServiceLabel: "web", composeapi.WorkingDirLabel: projectPath,
+ }},
+ {ID: "c2", State: "exited", Names: []string{"/inferred-db"}, Labels: map[string]string{
+ composeapi.ProjectLabel: "inferred", composeapi.ServiceLabel: "db", composeapi.WorkingDirLabel: projectPath,
+ }},
+ },
+ "known": {
+ {ID: "c3", State: "running", Names: []string{"/known-web"}, Labels: map[string]string{
+ composeapi.ProjectLabel: "known", composeapi.ServiceLabel: "web", composeapi.WorkingDirLabel: known.Path,
+ }},
+ },
+ }}
+
+ rows := service.projectListRowsInternal(context.Background(), projectsDir, []Project{inferred, known}, snapshot)
+ require.Len(t, rows, 2)
+ require.Equal(t, 2, rows[0].ServiceCount)
+ require.Equal(t, 4, rows[1].ServiceCount)
+
+ // The inferred count is persisted because the plain list path sorts and
+ // paginates on this column in SQL.
+ var stored Project
+ require.NoError(t, db.First(&stored, "id = ?", "inferred").Error)
+ require.Equal(t, 2, stored.ServiceCount)
+
+ var storedKnown Project
+ require.NoError(t, db.First(&storedKnown, "id = ?", "known").Error)
+ require.Equal(t, 4, storedKnown.ServiceCount, "a persisted non-zero count must not be overwritten by the live container count")
+}
+
func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSentinel(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -7188,14 +7230,9 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPres
require.NoDirExists(t, newPath)
}
-func TestProjectService_MapProjectToDto_SeedsHasBuildDirectiveFromPersistedRefs(t *testing.T) {
+func TestProjectListRow_SeedsHasBuildDirectiveFromPersistedRefs(t *testing.T) {
ctx := context.Background()
- db := setupProjectTestDB(t)
- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)
- require.NoError(t, err)
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load())
- metaEnv := &projectMetadataEnvInternal{projectsDirectory: t.TempDir()}
+ projectsDirectory := t.TempDir()
now := time.Now()
tests := []struct {
@@ -7211,7 +7248,7 @@ func TestProjectService_MapProjectToDto_SeedsHasBuildDirectiveFromPersistedRefs(
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := Project{ID: tt.name, Name: tt.name, Path: t.TempDir(), UpdatedAt: &now, BuildImageRefsJSON: tt.buildImageRefsJSON}
- assert.Equal(t, tt.want, svc.mapProjectToDto(ctx, metaEnv.projectsDirectory, p, nil, "", nil, svc.ProjectMetadata(ctx, p, metaEnv)).HasBuildDirective)
+ assert.Equal(t, tt.want, projectListRowInternal(ctx, projectsDirectory, p, projectContainerSnapshotInternal{}).HasBuildDirective)
})
}
}