69b4fe4065
1. As daemon.ContainerStop() documentation says, > If a negative number of seconds is given, ContainerStop > will wait for a graceful termination. but since commitcfdf84d5d0(PR #32237) this is no longer the case. This happens because `context.WithTimeout(ctx, timeout)` is implemented as `WithDeadline(ctx, time.Now().Add(timeout))`, resulting in a deadline which is in the past. To fix, don't use WithDeadline() if the timeout is negative. 2. Add a test case to validate the correct behavior and as a means to prevent a similar regression in the future. 3. Fix/improve daemon.ContainerStop() and client.ContainerStop() description for clarity and completeness. 4. Fix/improve DefaultStopTimeout description. Fixes:cfdf84d5d0("Update Container Wait") Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com>
89 lines
3.3 KiB
Go
89 lines
3.3 KiB
Go
package daemon // import "github.com/docker/docker/daemon"
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
containerpkg "github.com/docker/docker/container"
|
|
"github.com/docker/docker/errdefs"
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// ContainerStop looks for the given container and stops it.
|
|
// In case the container fails to stop gracefully within a time duration
|
|
// specified by the timeout argument, in seconds, it is forcefully
|
|
// terminated (killed).
|
|
//
|
|
// If the timeout is nil, the container's StopTimeout value is used, if set,
|
|
// otherwise the engine default. A negative timeout value can be specified,
|
|
// meaning no timeout, i.e. no forceful termination is performed.
|
|
func (daemon *Daemon) ContainerStop(name string, timeout *int) error {
|
|
container, err := daemon.GetContainer(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !container.IsRunning() {
|
|
return containerNotModifiedError{running: false}
|
|
}
|
|
if timeout == nil {
|
|
stopTimeout := container.StopTimeout()
|
|
timeout = &stopTimeout
|
|
}
|
|
if err := daemon.containerStop(container, *timeout); err != nil {
|
|
return errdefs.System(errors.Wrapf(err, "cannot stop container: %s", name))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// containerStop sends a stop signal, waits, sends a kill signal.
|
|
func (daemon *Daemon) containerStop(container *containerpkg.Container, seconds int) error {
|
|
if !container.IsRunning() {
|
|
return nil
|
|
}
|
|
|
|
stopSignal := container.StopSignal()
|
|
// 1. Send a stop signal
|
|
if err := daemon.killPossiblyDeadProcess(container, stopSignal); err != nil {
|
|
// While normally we might "return err" here we're not going to
|
|
// because if we can't stop the container by this point then
|
|
// it's probably because it's already stopped. Meaning, between
|
|
// the time of the IsRunning() call above and now it stopped.
|
|
// Also, since the err return will be environment specific we can't
|
|
// look for any particular (common) error that would indicate
|
|
// that the process is already dead vs something else going wrong.
|
|
// So, instead we'll give it up to 2 more seconds to complete and if
|
|
// by that time the container is still running, then the error
|
|
// we got is probably valid and so we force kill it.
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
|
|
if status := <-container.Wait(ctx, containerpkg.WaitConditionNotRunning); status.Err() != nil {
|
|
logrus.Infof("Container failed to stop after sending signal %d to the process, force killing", stopSignal)
|
|
if err := daemon.killPossiblyDeadProcess(container, 9); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Wait for the process to exit on its own
|
|
ctx := context.Background()
|
|
if seconds >= 0 {
|
|
var cancel context.CancelFunc
|
|
ctx, cancel = context.WithTimeout(ctx, time.Duration(seconds)*time.Second)
|
|
defer cancel()
|
|
}
|
|
|
|
if status := <-container.Wait(ctx, containerpkg.WaitConditionNotRunning); status.Err() != nil {
|
|
logrus.Infof("Container %v failed to exit within %d seconds of signal %d - using the force", container.ID, seconds, stopSignal)
|
|
// 3. If it doesn't, then send SIGKILL
|
|
if err := daemon.Kill(container); err != nil {
|
|
// Wait without a timeout, ignore result.
|
|
<-container.Wait(context.Background(), containerpkg.WaitConditionNotRunning)
|
|
logrus.Warn(err) // Don't return error because we only care that container is stopped, not what function stopped it
|
|
}
|
|
}
|
|
|
|
daemon.LogContainerEvent(container, "stop")
|
|
return nil
|
|
}
|