99 lines
2.8 KiB
Go
99 lines
2.8 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/containers/libpod/cmd/podman/cliconfig"
|
|
"github.com/containers/libpod/cmd/podman/libpodruntime"
|
|
"github.com/containers/libpod/cmd/podman/shared"
|
|
"github.com/containers/libpod/libpod"
|
|
"github.com/containers/libpod/pkg/rootless"
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
var (
|
|
stopCommand cliconfig.StopValues
|
|
stopDescription = `
|
|
podman stop
|
|
|
|
Stops one or more running containers. The container name or ID can be used.
|
|
A timeout to forcibly stop the container can also be set but defaults to 10
|
|
seconds otherwise.
|
|
`
|
|
_stopCommand = &cobra.Command{
|
|
Use: "stop",
|
|
Short: "Stop one or more containers",
|
|
Long: stopDescription,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
stopCommand.InputArgs = args
|
|
stopCommand.GlobalFlags = MainGlobalOpts
|
|
return stopCmd(&stopCommand)
|
|
},
|
|
Example: "CONTAINER-NAME [CONTAINER-NAME ...]",
|
|
}
|
|
)
|
|
|
|
func init() {
|
|
stopCommand.Command = _stopCommand
|
|
flags := stopCommand.Flags()
|
|
flags.BoolVarP(&stopCommand.All, "all", "a", false, "Stop all running containers")
|
|
flags.BoolVarP(&stopCommand.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
|
|
flags.UintVar(&stopCommand.Timeout, "time", libpod.CtrRemoveTimeout, "Seconds to wait for stop before killing the container")
|
|
flags.UintVarP(&stopCommand.Timeout, "timeout", "t", libpod.CtrRemoveTimeout, "Seconds to wait for stop before killing the container")
|
|
}
|
|
|
|
func stopCmd(c *cliconfig.StopValues) error {
|
|
|
|
if err := checkAllAndLatest(&c.PodmanCommand); err != nil {
|
|
return err
|
|
}
|
|
|
|
rootless.SetSkipStorageSetup(true)
|
|
runtime, err := libpodruntime.GetRuntime(&c.PodmanCommand)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "could not get runtime")
|
|
}
|
|
defer runtime.Shutdown(false)
|
|
|
|
containers, err := getAllOrLatestContainers(&c.PodmanCommand, runtime, libpod.ContainerStateRunning, "running")
|
|
if err != nil {
|
|
if len(containers) == 0 {
|
|
return err
|
|
}
|
|
fmt.Println(err.Error())
|
|
}
|
|
|
|
var stopFuncs []shared.ParallelWorkerInput
|
|
for _, ctr := range containers {
|
|
con := ctr
|
|
var stopTimeout uint
|
|
if c.Flag("timeout").Changed {
|
|
stopTimeout = c.Timeout
|
|
} else {
|
|
stopTimeout = ctr.StopTimeout()
|
|
}
|
|
f := func() error {
|
|
if err := con.StopWithTimeout(stopTimeout); err != nil && errors.Cause(err) != libpod.ErrCtrStopped {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
}
|
|
stopFuncs = append(stopFuncs, shared.ParallelWorkerInput{
|
|
ContainerID: con.ID(),
|
|
ParallelFunc: f,
|
|
})
|
|
}
|
|
|
|
maxWorkers := shared.Parallelize("stop")
|
|
if c.GlobalIsSet("max-workers") {
|
|
maxWorkers = c.GlobalFlags.MaxWorks
|
|
}
|
|
logrus.Debugf("Setting maximum workers to %d", maxWorkers)
|
|
|
|
stopErrors, errCount := shared.ParallelExecuteWorkerPool(maxWorkers, stopFuncs)
|
|
return printParallelOutput(stopErrors, errCount)
|
|
}
|