more tests

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

Author: ndeloof

pkg/compose/create.go

@@ -134,7 +134,7 @@ func (s *composeService) create(ctx context.Context, project *types.Project, opt
 	s.emitUntouchedContainerEvents(project, observed, plan)
 
 	// Phase 3: Execute the plan
-	return s.ExecutePlan(ctx, project, plan)
+	return s.ExecutePlan(ctx, project, plan, observed)
 }
 
 // emitUntouchedContainerEvents emits progress events for containers that are
@@ -143,13 +143,7 @@ func (s *composeService) emitUntouchedContainerEvents(project *types.Project, ob
 	for _, service := range project.Services {
 		for _, ctr := range observed.Containers[service.Name] {
 			ctrName := getCanonicalContainerName(ctr)
-			if _, touched := plan.Operations["stop-container:"+ctrName]; touched {
-				continue
-			}
-			if _, touched := plan.Operations["start-container:"+ctrName]; touched {
-				continue
-			}
-			if _, touched := plan.Operations["create-container:"+ctrName]; touched {
+			if plan.ContainerTouched(ctrName) {
 				continue
 			}
 			if ctr.State == container.StateRunning {

pkg/compose/observed_state_test.go

@@ -155,3 +155,62 @@ func TestReconciliationPlanString(t *testing.T) {
 `
 	assert.Equal(t, plan.String(), expected)
 }
+
+func TestContainerTouchedMatchesContainerOps(t *testing.T) {
+	plan := &ReconciliationPlan{
+		Operations: map[string]*Operation{
+			"stop-container:web-1": {
+				ID:   "stop-container:web-1",
+				Type: OpStopContainer,
+				ContainerOp: &ContainerOperation{
+					ContainerName: "web-1",
+				},
+			},
+			"create-container:tmpname_web-2": {
+				ID:   "create-container:tmpname_web-2",
+				Type: OpCreateContainer,
+				ContainerOp: &ContainerOperation{
+					ContainerName: "tmpname_web-2",
+				},
+			},
+			"rename-container:web-2": {
+				ID:   "rename-container:web-2",
+				Type: OpRenameContainer,
+				RenameOp: &RenameOperation{
+					CurrentName: "tmpname_web-2",
+					NewName:     "web-2",
+				},
+				// No ContainerOp — rename ops use RenameOp
+			},
+			"remove-container:db-1": {
+				ID:   "remove-container:db-1",
+				Type: OpRemoveContainer,
+				ContainerOp: &ContainerOperation{
+					ContainerName: "db-1",
+				},
+			},
+			"create-network:mynet": {
+				ID:   "create-network:mynet",
+				Type: OpCreateNetwork,
+				NetworkOp: &NetworkOperation{
+					NetworkKey: "default",
+				},
+			},
+		},
+		Dependents: map[string][]string{},
+	}
+
+	// Containers with ContainerOp are touched
+	assert.Assert(t, plan.ContainerTouched("web-1"), "stop op should mark web-1 as touched")
+	assert.Assert(t, plan.ContainerTouched("tmpname_web-2"), "create op should mark tmpname_web-2 as touched")
+	assert.Assert(t, plan.ContainerTouched("db-1"), "remove op should mark db-1 as touched")
+
+	// Rename ops have RenameOp, not ContainerOp — rename target is NOT touched via ContainerOp
+	assert.Assert(t, !plan.ContainerTouched("web-2"), "rename op (RenameOp only) should not mark web-2 as touched")
+
+	// Network ops are not container ops
+	assert.Assert(t, !plan.ContainerTouched("mynet"), "network op should not match container name")
+
+	// Non-existent container
+	assert.Assert(t, !plan.ContainerTouched("nonexistent"), "unknown container should not be touched")
+}

pkg/compose/plan_executor.go

@@ -29,8 +29,12 @@ import (
 	"github.com/compose-spec/compose-go/v2/types"
 	containerType "github.com/moby/moby/api/types/container"
 	"github.com/moby/moby/client"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
 	"golang.org/x/sync/errgroup"
 
+	"github.com/docker/compose/v5/internal/tracing"
 	"github.com/docker/compose/v5/pkg/api"
 )
 
@@ -148,19 +152,15 @@ func (es *executionState) resolveSharedNamespaces(service *types.ServiceConfig)
 // ExecutePlan executes a reconciliation plan using DAG traversal similar to
 // graphTraversal.visit() in dependencies.go. Operations are executed
 // concurrently, respecting dependency ordering.
-func (s *composeService) ExecutePlan(ctx context.Context, project *types.Project, plan *ReconciliationPlan) error {
+func (s *composeService) ExecutePlan(ctx context.Context, project *types.Project, plan *ReconciliationPlan, observed *ObservedState) error {
 	if plan.IsEmpty() {
 		return nil
 	}
 
 	// Pre-populate execution state with existing containers so that
 	// resolveServiceReferences can find containers for services not
 	// included in the plan (e.g. --no-deps scenarios).
-	allContainers, err := s.getContainers(ctx, project.Name, oneOffExclude, true)
-	if err != nil {
-		return err
-	}
-	state := newExecutionStateFrom(allContainers)
+	state := newExecutionStateFrom(observed.allContainers())
 
 	// Build dependency count map: number of unsatisfied deps per operation.
 	// The consumer goroutine is single-threaded, so no mutex is needed for depCount.
@@ -219,6 +219,30 @@ func (s *composeService) ExecutePlan(ctx context.Context, project *types.Project
 }
 
 func (s *composeService) executeOperation(ctx context.Context, project *types.Project, op *Operation, state *executionState) error {
+	spanName := op.Type.String()
+	opts := tracing.SpanOptions{}
+	if op.ContainerOp != nil {
+		opts = tracing.ServiceOptions(op.ContainerOp.Service)
+	}
+	ctx, span := otel.Tracer("").Start(ctx, spanName, opts.SpanStartOptions()...)
+	defer span.End()
+	span.SetAttributes(
+		attribute.String("operation.id", op.ID),
+		attribute.String("operation.resource", op.Resource),
+		attribute.String("operation.reason", op.Reason),
+	)
+
+	err := s.dispatchOperation(ctx, project, op, state)
+	if err != nil {
+		span.SetStatus(codes.Error, err.Error())
+		span.RecordError(err)
+	} else {
+		span.SetStatus(codes.Ok, "")
+	}
+	return err
+}
+
+func (s *composeService) dispatchOperation(ctx context.Context, project *types.Project, op *Operation, state *executionState) error {
 	switch op.Type {
 	case OpCreateNetwork:
 		return s.executePlanCreateNetwork(ctx, project, op, state)

pkg/compose/reconcile.go

@@ -165,6 +165,17 @@ func (p *ReconciliationPlan) IsEmpty() bool {
 	return len(p.Operations) == 0
 }
 
+// ContainerTouched reports whether the plan contains any operation that
+// directly affects the named container (stop, start, create, or remove).
+func (p *ReconciliationPlan) ContainerTouched(containerName string) bool {
+	for _, op := range p.Operations {
+		if op.ContainerOp != nil && op.ContainerOp.ContainerName == containerName {
+			return true
+		}
+	}
+	return false
+}
+
 // String returns a deterministic, test-friendly dump of the plan.
 //
 // Operations are listed in topological order, each prefixed by a sequential
@@ -502,9 +513,15 @@ func reconcileNetworks(project *types.Project, observed *ObservedState, plan *Re
 				Reason:    fmt.Sprintf("network %q has been recreated", n.Name),
 			}
 
-			// Start the container (depends on connect)
+			// Start the container (depends on all connect ops for this container)
 			startID := fmt.Sprintf("start-container:%s", ctrName)
-			if _, exists := plan.Operations[startID]; !exists {
+			if existing, exists := plan.Operations[startID]; exists {
+				// Container is connected to multiple recreated networks;
+				// add the new connect op as a dependency.
+				if !slices.Contains(existing.DependsOn, connectID) {
+					existing.DependsOn = append(existing.DependsOn, connectID)
+				}
+			} else {
 				plan.Operations[startID] = &Operation{
 					ID:          startID,
 					Type:        OpStartContainer,
@@ -1098,7 +1115,7 @@ func needsRecreate(expected types.ServiceConfig, actual container.Summary, netwo
 		return true, "image digest changed", nil
 	}
 
-	if networks != nil && actual.State == container.StateRunning {
+	if networks != nil && actual.State == container.StateRunning && actual.NetworkSettings != nil {
 		if checkExpectedNetworks(expected, actual, networks) {
 			return true, "network configuration changed", nil
 		}
@@ -1164,13 +1181,9 @@ func addCascadingRestarts(project *types.Project, observed *ObservedState, plan
 				continue
 			}
 			// This service's dependency is being recreated and has restart: true.
-			// Add stop+start ops for its running containers (if not already being recreated/stopped).
+			// Add stop+start ops for its running containers (if not already being stopped).
 			for _, ctr := range observed.Containers[service.Name] {
 				ctrName := getCanonicalContainerName(ctr)
-				// Skip if we already have operations for this container
-				if _, exists := plan.Operations["recreate-container:"+ctrName]; exists {
-					continue
-				}
 				if _, exists := plan.Operations["stop-container:"+ctrName]; exists {
 					continue
 				}