fix(reconcile): a provider's consumer waits for its deployment too

Copilot review: planProviderStart used a provider's own depends_on
wait nodes as its startChainEnds whenever it had any, entirely
dropping its own OpRunProvider (deployment) node from that set. A
downstream consumer of the provider -- ordered after startChainEnds
-- would then only wait for the provider's dependency to become
healthy, not for the provider plugin/relay deployment itself to
finish. The old create-then-start two-phase barrier guaranteed that
ordering for free; ScopeCreateStart (inert until this PR actually
exercised it end to end) didn't reproduce it.

ends now always includes the provider's own node alongside its
dependency prerequisites when it has any, instead of either/or.

TestPlanStart_ProviderConsumerWaitsForDeployment pins it: a provider
with both an upstream dependency and a downstream consumer, asserting
the consumer's start node depends on the provider's OpRunProvider node
directly -- verified by ablation to fail (showing the exact missing
edge) without the fix.

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>
This commit is contained in:
Nicolas De Loof 2026-10-06 18:09:04 +02:00
parent 570e0944a7
commit e206f05665
No known key found for this signature in database
2 changed files with 62 additions and 5 deletions

View file

@ -1305,17 +1305,22 @@ func (r *reconciler) waitConditionNode(dep string, cfg types.ServiceDependency,
// planProviderStart is the start-phase visit of a provider service: no
// container to start, but its own depends_on still applies — the imperative
// startService waits on it for every service, providers included. Its chain
// end is those prerequisites, else its create-phase RunProvider node.
// end is its create-phase RunProvider node (the deployment itself), plus
// those dependency prerequisites when it has any -- a consumer must wait for
// both: the provider's own dependencies satisfied AND the provider actually
// deployed, not either in isolation. Before this ordering was corrected, a
// provider with both an upstream dependency and a downstream consumer let
// the dependency wait substitute for the deploy node entirely, so the
// consumer could start while the provider's plugin/relay deployment was
// still running.
func (r *reconciler) planProviderStart(service types.ServiceConfig) error {
depNodes, err := r.startPhaseDependencies(service)
if err != nil {
return err
}
ends := depNodes
if len(ends) == 0 {
if node, ok := r.serviceNodes[service.Name]; ok {
ends = []*PlanNode{node}
}
if node, ok := r.serviceNodes[service.Name]; ok && !slices.Contains(ends, node) {
ends = append(ends, node)
}
if len(ends) > 0 {
r.startChainEnds[service.Name] = ends

View file

@ -381,6 +381,58 @@ func TestPlanStart_ProviderWaitsOnDependencies(t *testing.T) {
assert.Equal(t, wait.Operation.Condition, types.ServiceConditionHealthy)
}
// TestPlanStart_ProviderConsumerWaitsForDeployment is a regression test for
// a Copilot review finding on #14290: once ScopeCreateStart became the real,
// exercised path for detached up, planProviderStart's startChainEnds for a
// provider WITH its own depends_on was just that dependency's wait node --
// dropping the provider's own OpRunProvider (deployment) node entirely. A
// downstream consumer of the provider could therefore start while the
// provider plugin/relay deployment was still running, a barrier the old
// create-then-start two-phase sequence guaranteed for free.
func TestPlanStart_ProviderConsumerWaitsForDeployment(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"}
consumer := serviceWithDeps("consumer", types.DependsOnConfig{"prov": {Condition: types.ServiceConditionStarted, Required: true}})
project := &types.Project{
Name: "myproject",
Services: types.Services{"db": db, "prov": prov, "consumer": consumer},
}
dbHash, err := serviceHashWithResolvedRefs(db, nil)
assert.NilError(t, err)
consumerHash, err := serviceHashWithResolvedRefs(consumer, nil)
assert.NilError(t, err)
observed := emptyObserved()
observed.Containers["db"] = []ObservedContainer{
observedServiceContainer("db", 1, container.StateRunning, dbHash),
}
observed.Containers["consumer"] = []ObservedContainer{
observedServiceContainer("consumer", 1, container.StateExited, consumerHash),
}
plan, err := reconcile(t.Context(), project, observed, startScopeOptions(ScopeCreateStart), noPrompt)
assert.NilError(t, err)
var providerNode, consumerStartNode *PlanNode
for _, n := range plan.Nodes {
switch {
case n.Operation.Type == OpRunProvider:
providerNode = n
case n.Operation.Type == OpStartContainer && n.Operation.ResourceID == "service:consumer:1":
consumerStartNode = n
}
}
if providerNode == nil {
t.Fatalf("expected an OpRunProvider node for prov:\n%s", plan)
}
if consumerStartNode == nil {
t.Fatalf("expected a start node for consumer:\n%s", plan)
}
assert.Assert(t, slices.Contains(consumerStartNode.DependsOn, providerNode),
"consumer's start must depend on the provider's own deployment node, not just its depends_on wait:\n%s", plan)
}
// A replica condemned by scale-down must never receive a start-phase node:
// the imperative engine only starts what survives the convergence — and the
// condemned replica does not count as running for the pre_start gating.