compose/pkg/compose/remove.go
Guillaume Lours 6d3d68c1fa fix(display): stop ttyWriter.Done from hanging after context cancel
Fixes #14114: Done() blocked forever once the render goroutine had
already exited via ctx.Done() (e.g. after SIGTERM), since it sent on an
unbuffered channel with nobody left to receive.

Closing the channel instead of sending never blocks, but a bare close()
panics the moment ttyWriter runs a second Start/Done cycle on the same
shared bus - which already happens today (run's nested create/start,
publish's nested push, rm --stop's sequential stop then remove). Start
now hands out a fresh, once-only-closable signal each cycle instead of
a single shared channel, and run/publish stop opening a redundant
nested bracket around calls already inside one.

Signed-off-by: Guillaume Lours <glours@users.noreply.github.com>
2026-08-25 11:38:50 +02:00

117 lines
3.2 KiB
Go

/*
Copyright 2020 Docker Compose CLI authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compose
import (
"context"
"fmt"
"strings"
"github.com/moby/moby/client"
"golang.org/x/sync/errgroup"
"github.com/docker/compose/v5/pkg/api"
)
func (s *composeService) Remove(ctx context.Context, projectName string, options api.RemoveOptions) error {
projectName = strings.ToLower(projectName)
if options.Stop {
// Stop's own "stop" Start/Done cycle runs sequentially, fully
// closed, before "remove"'s below — ttyWriter supports that.
err := s.Stop(ctx, projectName, api.StopOptions{
Services: options.Services,
Project: options.Project,
})
if err != nil {
return err
}
}
containers, err := s.getContainers(ctx, projectName, oneOffExclude, true, options.Services...)
if err != nil {
if api.IsNotFoundError(err) {
_, _ = fmt.Fprintln(s.stderr(), "No stopped containers")
return nil
}
return err
}
if options.Project != nil {
containers = containers.filter(isService(options.Project.ServiceNames()...))
}
var stoppedContainers Containers
for _, ctr := range containers {
// We have to inspect containers, as State reported by getContainers suffers a race condition
inspected, err := s.apiClient().ContainerInspect(ctx, ctr.ID, client.ContainerInspectOptions{})
if api.IsNotFoundError(err) {
// Already removed. Maybe configured with auto-remove
continue
}
if err != nil {
return err
}
if !inspected.Container.State.Running || (options.Stop && s.dryRun) {
stoppedContainers = append(stoppedContainers, ctr)
}
}
var names []string
for _, ctr := range stoppedContainers {
names = append(names, getCanonicalContainerName(ctr))
}
if len(names) == 0 {
return api.ErrNoResources
}
msg := fmt.Sprintf("Going to remove %s", strings.Join(names, ", "))
if options.Force {
_, _ = fmt.Fprintln(s.stdout(), msg)
} else {
confirm, err := s.prompt(msg, false)
if err != nil {
return err
}
if !confirm {
return nil
}
}
return Run(ctx, func(ctx context.Context) error {
return s.remove(ctx, stoppedContainers, options)
}, "remove", s.events)
}
func (s *composeService) remove(ctx context.Context, containers Containers, options api.RemoveOptions) error {
eg, ctx := errgroup.WithContext(ctx)
for _, ctr := range containers {
eg.Go(func() error {
eventName := getContainerProgressName(ctr)
s.events.On(removingEvent(eventName))
_, err := s.apiClient().ContainerRemove(ctx, ctr.ID, client.ContainerRemoveOptions{
RemoveVolumes: options.Volumes,
Force: options.Force,
})
if err == nil {
s.events.On(removedEvent(eventName))
}
return err
})
}
return eg.Wait()
}