2014-07-31 16:40:15 -04:00
|
|
|
package daemon
|
|
|
|
|
2015-09-16 14:56:26 -04:00
|
|
|
import (
|
2015-11-02 18:25:26 -05:00
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/Sirupsen/logrus"
|
2015-09-17 14:54:14 -04:00
|
|
|
derr "github.com/docker/docker/errors"
|
2015-09-16 14:56:26 -04:00
|
|
|
)
|
2015-03-25 03:44:12 -04:00
|
|
|
|
2015-07-30 17:01:53 -04:00
|
|
|
// ContainerStop looks for the given container and terminates it,
|
|
|
|
// waiting the given number of seconds before forcefully killing the
|
|
|
|
// container. If a negative number of seconds is given, ContainerStop
|
|
|
|
// will wait for a graceful termination. An error is returned if the
|
|
|
|
// container is not found, is already stopped, or if there is a
|
|
|
|
// problem stopping the container.
|
2015-09-29 13:51:40 -04:00
|
|
|
func (daemon *Daemon) ContainerStop(name string, seconds int) error {
|
|
|
|
container, err := daemon.Get(name)
|
2014-12-16 18:06:35 -05:00
|
|
|
if err != nil {
|
2015-03-25 03:44:12 -04:00
|
|
|
return err
|
2014-07-31 16:40:15 -04:00
|
|
|
}
|
2014-12-16 18:06:35 -05:00
|
|
|
if !container.IsRunning() {
|
2015-09-16 14:56:26 -04:00
|
|
|
return derr.ErrorCodeStopped
|
2014-12-16 18:06:35 -05:00
|
|
|
}
|
2015-11-02 18:25:26 -05:00
|
|
|
if err := daemon.containerStop(container, seconds); err != nil {
|
2015-09-16 14:56:26 -04:00
|
|
|
return derr.ErrorCodeCantStop.WithArgs(name, err)
|
2014-12-16 18:06:35 -05:00
|
|
|
}
|
2015-03-25 03:44:12 -04:00
|
|
|
return nil
|
2014-07-31 16:40:15 -04:00
|
|
|
}
|
2015-11-02 18:25:26 -05:00
|
|
|
|
|
|
|
// containerStop halts a container by sending a stop signal, waiting for the given
|
|
|
|
// duration in seconds, and then calling SIGKILL and waiting for the
|
|
|
|
// process to exit. If a negative duration is given, Stop will wait
|
|
|
|
// for the initial signal forever. If the container is not running Stop returns
|
|
|
|
// immediately.
|
|
|
|
func (daemon *Daemon) containerStop(container *Container, seconds int) error {
|
|
|
|
if !container.IsRunning() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// 1. Send a SIGTERM
|
|
|
|
if err := daemon.killPossiblyDeadProcess(container, container.stopSignal()); err != nil {
|
|
|
|
logrus.Infof("Failed to send SIGTERM to the process, force killing")
|
|
|
|
if err := daemon.killPossiblyDeadProcess(container, 9); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 2. Wait for the process to exit on its own
|
|
|
|
if _, err := container.WaitStop(time.Duration(seconds) * time.Second); err != nil {
|
|
|
|
logrus.Infof("Container %v failed to exit within %d seconds of SIGTERM - using the force", container.ID, seconds)
|
|
|
|
// 3. If it doesn't, then send SIGKILL
|
|
|
|
if err := daemon.Kill(container); err != nil {
|
|
|
|
container.WaitStop(-1 * time.Second)
|
|
|
|
logrus.Warn(err) // Don't return error because we only care that container is stopped, not what function stopped it
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-03 12:33:13 -05:00
|
|
|
daemon.LogContainerEvent(container, "stop")
|
2015-11-02 18:25:26 -05:00
|
|
|
return nil
|
|
|
|
}
|