diff --git a/pkg/compose/reconcile.go b/pkg/compose/reconcile.go index 150c7ed8e..790f1e1c0 100644 --- a/pkg/compose/reconcile.go +++ b/pkg/compose/reconcile.go @@ -1405,7 +1405,7 @@ func (r *reconciler) planProviderStart(service types.ServiceConfig) error { // rebuild): that is an explicit request to leave it alone, not the // create phase never having run, so it must not fall through to // planProviderRelayRestart. - if restart := r.planProviderRelayRestart(service); restart != nil { + if restart := r.planProviderRelayRestart(service, depNodes); restart != nil { ends = append(ends, restart) } } @@ -1423,7 +1423,14 @@ func (r *reconciler) planProviderStart(service types.ServiceConfig) error { // never a redeploy -- ensureServiceRelay's own convergence stays a create-phase // concern, triggered by OpRunProvider, which a caller needing it re-run // (e.g. config drift) gets via ScopeCreateStart, not this. -func (r *reconciler) planProviderRelayRestart(service types.ServiceConfig) *PlanNode { +// +// deps is the provider's own startPhaseDependencies: under pure ScopeStart +// there is no Create->Start barrier separating this provider from its +// siblings (unlike ScopeCreateStart's OpRunProvider, always a create-phase +// node), so without its own depends_on wired in here, the relay could start +// before a required dependency's health/condition wait resolves -- a Copilot +// review finding on the first version of this fix. +func (r *reconciler) planProviderRelayRestart(service types.ServiceConfig, deps []*PlanNode) *PlanNode { for i := range r.observed.Containers[service.Name] { oc := &r.observed.Containers[service.Name][i] if !isRelayContainer(oc.Summary) || oc.State == container.StateRunning { @@ -1435,7 +1442,7 @@ func (r *reconciler) planProviderRelayRestart(service types.ServiceConfig) *Plan ResourceID: resID, Cause: "start", Container: &oc.Summary, - }, startGroupID(resID)) + }, startGroupID(resID), deps...) node.Phase = PhaseStart return node } diff --git a/pkg/compose/reconcile_start_test.go b/pkg/compose/reconcile_start_test.go index 7f17ce4fb..9af7e1005 100644 --- a/pkg/compose/reconcile_start_test.go +++ b/pkg/compose/reconcile_start_test.go @@ -817,6 +817,52 @@ func TestPlanStart_ProviderRelayRestartRespectsSkipProviders(t *testing.T) { assert.Equal(t, len(plan.Nodes), 0, "SkipProviders must leave a stopped relay untouched:\n%s", plan) } +// TestPlanStart_ProviderRelayRestartWaitsOnDependencies is a regression test +// for a Copilot review finding on planProviderRelayRestart: under pure +// ScopeStart there is no Create->Start barrier separating a provider from +// its siblings (unlike ScopeCreateStart's OpRunProvider, always a +// create-phase node run to completion before any start-phase node begins). +// Without its own depends_on wired into the relay-restart node, a stopped +// relay could start before a required dependency's health condition +// resolved. +func TestPlanStart_ProviderRelayRestartWaitsOnDependencies(t *testing.T) { + db := types.ServiceConfig{Name: "db"} + db.HealthCheck = &types.HealthCheckConfig{Test: []string{"CMD", "true"}} + prov := serviceWithDeps("prov", types.DependsOnConfig{ + "db": {Condition: types.ServiceConditionHealthy, Required: true}, + }) + prov.Provider = &types.ServiceProviderConfig{Type: "test"} + project := &types.Project{ + Name: "myproject", + Services: types.Services{"db": db, "prov": prov}, + } + dbHash, err := serviceHashWithResolvedRefs(db, nil) + assert.NilError(t, err) + observed := emptyObserved() + observed.Containers["db"] = []ObservedContainer{observedServiceContainer("db", 1, container.StateRunning, dbHash)} + relay := observedServiceContainer("prov", 1, container.StateExited, "") + relay.Summary.Labels[api.RelayLabel] = "relay-abc123" + observed.Containers["prov"] = []ObservedContainer{relay} + + plan, err := reconcile(t.Context(), project, observed, startScopeOptions(ScopeStart), noPrompt) + assert.NilError(t, err) + + var wait, restart *PlanNode + for _, n := range plan.Nodes { + switch { + case n.Operation.Type == OpWaitCondition: + wait = n + case n.Operation.Type == OpStartContainer && n.Operation.ResourceID == "service:prov:1": + restart = n + } + } + if wait == nil || restart == nil { + t.Fatalf("expected db's wait node and prov's relay restart node:\n%s", plan) + } + assert.Assert(t, slices.Contains(restart.DependsOn, wait), + "the relay restart must depend on prov's own depends_on wait, not start unconditionally:\n%s", plan) +} + // An optional (required: false) condition marks the shared wait node // best-effort — a missing dependency is skipped, not fatal; one required // dependent upgrades the node for everyone.