more tests

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

Author: ndeloof

pkg/compose/create.go

@@ -109,10 +109,13 @@ func (s *composeService) create(ctx context.Context, project *types.Project, opt
 		}
 	}
 
-	// Validate external networks exist before reconciling
+	// Validate external resources exist before reconciling
 	if err := s.validateExternalNetworks(ctx, project, options.Services); err != nil {
 		return err
 	}
+	if err := s.validateExternalVolumes(ctx, project, options.Services); err != nil {
+		return err
+	}
 
 	// Phase 2: Reconcile desired vs observed state (pure function)
 	plan, err := Reconcile(project, observed, ReconcileOptions{
@@ -127,14 +130,14 @@ func (s *composeService) create(ctx context.Context, project *types.Project, opt
 		return err
 	}
 
+	s.emitUntouchedContainerEvents(project, observed, plan)
+
 	if plan.IsEmpty() {
 		return nil
 	}
 
-	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 +146,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 {
@@ -189,6 +186,44 @@ func (s *composeService) validateExternalNetworks(ctx context.Context, project *
 	return nil
 }
 
+// validateExternalVolumes checks that external volumes exist for services
+// that are part of the current operation. Returns an error if a required
+// external volume is not found.
+func (s *composeService) validateExternalVolumes(ctx context.Context, project *types.Project, services []string) error {
+	for key, vol := range project.Volumes {
+		if !vol.External {
+			continue
+		}
+		// Check if any targeted service uses this volume
+		usedByTargetedService := false
+		for _, service := range project.Services {
+			if len(services) > 0 && !slices.Contains(services, service.Name) {
+				continue
+			}
+			for _, v := range service.Volumes {
+				if v.Type == string(mount.TypeVolume) && v.Source == key {
+					usedByTargetedService = true
+					break
+				}
+			}
+			if usedByTargetedService {
+				break
+			}
+		}
+		if !usedByTargetedService {
+			continue
+		}
+		_, err := s.apiClient().VolumeInspect(ctx, vol.Name, client.VolumeInspectOptions{})
+		if err != nil {
+			if errdefs.IsNotFound(err) {
+				return fmt.Errorf("external volume %q not found", vol.Name)
+			}
+			return err
+		}
+	}
+	return nil
+}
+
 func prepareNetworks(project *types.Project) {
 	for k, nw := range project.Networks {
 		nw.CustomLabels = nw.CustomLabels.

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)
@@ -397,7 +421,10 @@ func (s *composeService) executePlanRunPlugin(ctx context.Context, project *type
 // DisplayPlan performs a topological sort of operations and displays them
 // grouped by resource type.
 func DisplayPlan(plan *ReconciliationPlan, w io.Writer) error {
-	ops := topologicalSort(plan)
+	ops, err := topologicalSort(plan)
+	if err != nil {
+		return err
+	}
 
 	// Group operations by category
 	var networkOps, volumeOps []*Operation
@@ -497,7 +524,8 @@ func opVerb(t OperationType) string {
 }
 
 // topologicalSort returns operations in dependency order using Kahn's algorithm.
-func topologicalSort(plan *ReconciliationPlan) []*Operation {
+// Returns an error if the dependency graph contains a cycle.
+func topologicalSort(plan *ReconciliationPlan) ([]*Operation, error) {
 	inDegree := make(map[string]int, len(plan.Operations))
 	for _, op := range plan.Operations {
 		inDegree[op.ID] = len(op.DependsOn)
@@ -529,5 +557,16 @@ func topologicalSort(plan *ReconciliationPlan) []*Operation {
 		queue = append(queue, next...)
 	}
 
-	return sorted
+	if len(sorted) != len(plan.Operations) {
+		var cycled []string
+		for id, degree := range inDegree {
+			if degree > 0 {
+				cycled = append(cycled, id)
+			}
+		}
+		sort.Strings(cycled)
+		return nil, fmt.Errorf("dependency cycle detected involving operations: %v", cycled)
+	}
+
+	return sorted, nil
 }