Method planRecreateNetwork

pkg/compose/reconcile.go:186–239

planRecreateNetwork adds the full sequence for a diverged network: stop affected containers → disconnect → remove network → create network.

(key string, nw *types.NetworkConfig)

// planRecreateNetwork adds the full sequence for a diverged network:
// stop affected containers → disconnect → remove network → create network.
func (r *reconciler) planRecreateNetwork(key string, nw *types.NetworkConfig) error {
	observed := r.observed.Networks[key]
	affectedServices := r.servicesUsingNetwork(key)
	affectedContainers := r.containersForServices(affectedServices)

	// Stop all affected containers, recording each Stop node so that a later
	// recreate of the same container does not emit a second Stop against a
	// container that is already stopped.
	var stopNodes []*PlanNode
	for i := range affectedContainers {
		oc := &affectedContainers[i]
		node := r.plan.addNode(Operation{
			Type:       OpStopContainer,
			ResourceID: fmt.Sprintf("service:%s:%d", oc.Summary.Labels[api.ServiceLabel], oc.Number),
			Cause:      fmt.Sprintf("network %s config changed", key),
			Container:  &oc.Summary,
		}, "")
		stopNodes = append(stopNodes, node)
		r.stoppedByPlan[oc.ID] = node
	}

	// Disconnect all affected containers from the *observed* network (each depends on its own stop)
	var disconnectNodes []*PlanNode
	for i, oc := range affectedContainers {
		node := r.plan.addNode(Operation{
			Type:       OpDisconnectNetwork,
			ResourceID: fmt.Sprintf("service:%s:%d", oc.Summary.Labels[api.ServiceLabel], oc.Number),
			Cause:      fmt.Sprintf("network %s recreate", key),
			Container:  &affectedContainers[i].Summary,
			Name:       observed.Name,
		}, "", stopNodes[i])
		disconnectNodes = append(disconnectNodes, node)
	}

	// Remove the *observed* network (depends on all disconnects)
	removeNode := r.plan.addNode(Operation{
		Type:       OpRemoveNetwork,
		ResourceID: fmt.Sprintf("network:%s", key),
		Cause:      "config hash diverged",
		Name:       observed.Name,
	}, "", disconnectNodes...)

	// Create network (depends on remove)
	createNode := r.plan.addNode(Operation{
		Type:       OpCreateNetwork,
		ResourceID: fmt.Sprintf("network:%s", key),
		Cause:      "recreate after config change",
		Name:       nw.Name,
		Network:    nw,
	}, "", removeNode)
	r.networkNodes[key] = createNode

	return nil
}

// reconcileVolumes adds plan nodes for volume creation. Recreation of a
// diverged volume is handled by ensureProjectVolumes (which already prompts