containers
/
podman
mirror of https://github.com/containers/podman.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove libpod from main 

the compilation demands of having libpod in main is a burden for the
remote client compilations.  to combat this, we should move the use of
libpod structs, vars, constants, and functions into the adapter code
where it will only be compiled by the local client.

this should result in cleaner code organization and smaller binaries. it
should also help if we ever need to compile the remote client on
non-Linux operating systems natively (not cross-compiled).

Signed-off-by: baude <bbaude@redhat.com>
This commit is contained in:
baude 2019-06-24 15:48:34 -05:00
parent a1a4a75abe
commit dd81a44ccf
72 changed files with 822 additions and 746 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
cmd/podman/checkpoint.go
View File

@ -2,7 +2,6 @@ package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -59,13 +58,7 @@ func checkpointCmd(c *cliconfig.CheckpointValues) error {
if err != nil { if err != nil {
return errors.Wrapf(err, "could not get runtime") return errors.Wrapf(err, "could not get runtime")
} }
defer runtime.Shutdown(false)
options := libpod.ContainerCheckpointOptions{ defer runtime.Shutdown(false)
Keep: c.Keep, return runtime.Checkpoint(c)
KeepRunning: c.LeaveRunning,
TCPEstablished: c.TcpEstablished,
TargetFile: c.Export,
}
return runtime.Checkpoint(c, options)
} }

8
cmd/podman/commit.go
View File

@ -5,7 +5,6 @@ import (
"strings" "strings"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -30,6 +29,9 @@ var (
podman commit -q --author "firstName lastName" reverent_golick image-committed podman commit -q --author "firstName lastName" reverent_golick image-committed
podman commit -q --pause=false containerID image-committed`, podman commit -q --pause=false containerID image-committed`,
} }
// ChangeCmds is the list of valid Changes commands to passed to the Commit call
ChangeCmds = []string{"CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"}
) )
func init() { func init() {
@ -37,7 +39,7 @@ func init() {
commitCommand.SetHelpTemplate(HelpTemplate()) commitCommand.SetHelpTemplate(HelpTemplate())
commitCommand.SetUsageTemplate(UsageTemplate()) commitCommand.SetUsageTemplate(UsageTemplate())
flags := commitCommand.Flags() flags := commitCommand.Flags()
flags.StringArrayVarP(&commitCommand.Change, "change", "c", []string{}, fmt.Sprintf("Apply the following possible instructions to the created image (default []): %s", strings.Join(libpod.ChangeCmds, " | "))) flags.StringArrayVarP(&commitCommand.Change, "change", "c", []string{}, fmt.Sprintf("Apply the following possible instructions to the created image (default []): %s", strings.Join(ChangeCmds, " | ")))
flags.StringVarP(&commitCommand.Format, "format", "f", "oci", "`Format` of the image manifest and metadata") flags.StringVarP(&commitCommand.Format, "format", "f", "oci", "`Format` of the image manifest and metadata")
flags.StringVarP(&commitCommand.Message, "message", "m", "", "Set commit message for imported image") flags.StringVarP(&commitCommand.Message, "message", "m", "", "Set commit message for imported image")
flags.StringVarP(&commitCommand.Author, "author", "a", "", "Set the author for the image committed") flags.StringVarP(&commitCommand.Author, "author", "a", "", "Set the author for the image committed")
@ -66,7 +68,7 @@ func commitCmd(c *cliconfig.CommitValues) error {
if len(splitChange) == 1 { if len(splitChange) == 1 {
splitChange = strings.Split(strings.ToUpper(change), " ") splitChange = strings.Split(strings.ToUpper(change), " ")
} }
if !util.StringInSlice(splitChange[0], libpod.ChangeCmds) { if !util.StringInSlice(splitChange[0], ChangeCmds) {
return errors.Errorf("invalid syntax for --change: %s", change) return errors.Errorf("invalid syntax for --change: %s", change)
} }
} }

58
cmd/podman/common.go
View File

@ -9,7 +9,7 @@ import (
"github.com/containers/buildah" "github.com/containers/buildah"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/containers/storage" "github.com/containers/storage"
"github.com/fatih/camelcase" "github.com/fatih/camelcase"
@ -80,58 +80,6 @@ func commandRunE() func(*cobra.Command, []string) error {
} }
} }
// getAllOrLatestContainers tries to return the correct list of containers
// depending if --all, --latest or <container-id> is used.
// It requires the Context (c) and the Runtime (runtime). As different
// commands are using different container state for the --all option
// the desired state has to be specified in filterState. If no filter
// is desired a -1 can be used to get all containers. For a better
// error message, if the filter fails, a corresponding verb can be
// specified which will then appear in the error message.
func getAllOrLatestContainers(c *cliconfig.PodmanCommand, runtime *libpod.Runtime, filterState libpod.ContainerStatus, verb string) ([]*libpod.Container, error) {
var containers []*libpod.Container
var lastError error
var err error
if c.Bool("all") {
if filterState != -1 {
var filterFuncs []libpod.ContainerFilter
filterFuncs = append(filterFuncs, func(c *libpod.Container) bool {
state, _ := c.State()
return state == filterState
})
containers, err = runtime.GetContainers(filterFuncs...)
} else {
containers, err = runtime.GetContainers()
}
if err != nil {
return nil, errors.Wrapf(err, "unable to get %s containers", verb)
}
} else if c.Bool("latest") {
lastCtr, err := runtime.GetLatestContainer()
if err != nil {
return nil, errors.Wrapf(err, "unable to get latest container")
}
containers = append(containers, lastCtr)
} else {
args := c.InputArgs
for _, i := range args {
container, err := runtime.LookupContainer(i)
if err != nil {
if lastError != nil {
fmt.Fprintln(os.Stderr, lastError)
}
lastError = errors.Wrapf(err, "unable to find container %s", i)
}
if container != nil {
// This is here to make sure this does not return [<nil>] but only nil
containers = append(containers, container)
}
}
}
return containers, lastError
}
// getContext returns a non-nil, empty context // getContext returns a non-nil, empty context
func getContext() context.Context { func getContext() context.Context {
if Ctx != nil { if Ctx != nil {
@ -333,7 +281,7 @@ func getCreateFlags(c *cliconfig.PodmanCommand) {
createFlags.String( createFlags.String(
"init-path", "", "init-path", "",
// Do not use the Value field for setting the default value to determine user input (i.e., non-empty string) // Do not use the Value field for setting the default value to determine user input (i.e., non-empty string)
fmt.Sprintf("Path to the container-init binary (default: %q)", libpod.DefaultInitPath), fmt.Sprintf("Path to the container-init binary (default: %q)", define.DefaultInitPath),
) )
createFlags.BoolP( createFlags.BoolP(
"interactive", "i", false, "interactive", "i", false,
@ -472,7 +420,7 @@ func getCreateFlags(c *cliconfig.PodmanCommand) {
"Signal to stop a container. Default is SIGTERM", "Signal to stop a container. Default is SIGTERM",
) )
createFlags.Uint( createFlags.Uint(
"stop-timeout", libpod.CtrRemoveTimeout, "stop-timeout", define.CtrRemoveTimeout,
"Timeout (in seconds) to stop a container. Default is 10", "Timeout (in seconds) to stop a container. Default is 10",
) )
createFlags.StringSlice( createFlags.StringSlice(

64
cmd/podman/common_libpod.go Normal file
View File

@ -0,0 +1,64 @@
//build !remoteclient
package main
import (
"fmt"
"os"
"github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod"
"github.com/pkg/errors"
)
// getAllOrLatestContainers tries to return the correct list of containers
// depending if --all, --latest or <container-id> is used.
// It requires the Context (c) and the Runtime (runtime). As different
// commands are using different container state for the --all option
// the desired state has to be specified in filterState. If no filter
// is desired a -1 can be used to get all containers. For a better
// error message, if the filter fails, a corresponding verb can be
// specified which will then appear in the error message.
func getAllOrLatestContainers(c *cliconfig.PodmanCommand, runtime *libpod.Runtime, filterState libpod.ContainerStatus, verb string) ([]*libpod.Container, error) {
var containers []*libpod.Container
var lastError error
var err error
if c.Bool("all") {
if filterState != -1 {
var filterFuncs []libpod.ContainerFilter
filterFuncs = append(filterFuncs, func(c *libpod.Container) bool {
state, _ := c.State()
return state == filterState
})
containers, err = runtime.GetContainers(filterFuncs...)
} else {
containers, err = runtime.GetContainers()
}
if err != nil {
return nil, errors.Wrapf(err, "unable to get %s containers", verb)
}
} else if c.Bool("latest") {
lastCtr, err := runtime.GetLatestContainer()
if err != nil {
return nil, errors.Wrapf(err, "unable to get latest container")
}
containers = append(containers, lastCtr)
} else {
args := c.InputArgs
for _, i := range args {
container, err := runtime.LookupContainer(i)
if err != nil {
if lastError != nil {
fmt.Fprintln(os.Stderr, lastError)
}
lastError = errors.Wrapf(err, "unable to find container %s", i)
}
if container != nil {
// This is here to make sure this does not return [<nil>] but only nil
containers = append(containers, container)
}
}
}
return containers, lastError
}

4
cmd/podman/containers_prune.go
View File

@ -3,7 +3,7 @@ package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -51,7 +51,7 @@ func pruneContainersCmd(c *cliconfig.PruneContainersValues) error {
} }
ok, failures, err := runtime.Prune(getContext(), maxWorkers, c.Force) ok, failures, err := runtime.Prune(getContext(), maxWorkers, c.Force)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
if len(c.InputArgs) > 1 { if len(c.InputArgs) > 1 {
exitCode = 125 exitCode = 125
} else { } else {

7
cmd/podman/cp.go
View File

@ -13,14 +13,15 @@ import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/libpodruntime" "github.com/containers/libpod/cmd/podman/libpodruntime"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/containers/storage" "github.com/containers/storage"
"github.com/containers/storage/pkg/archive" "github.com/containers/storage/pkg/archive"
"github.com/containers/storage/pkg/chrootarchive" "github.com/containers/storage/pkg/chrootarchive"
"github.com/containers/storage/pkg/idtools" "github.com/containers/storage/pkg/idtools"
securejoin "github.com/cyphar/filepath-securejoin" securejoin "github.com/cyphar/filepath-securejoin"
digest "github.com/opencontainers/go-digest" "github.com/opencontainers/go-digest"
specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -114,7 +115,7 @@ func copyBetweenHostAndContainer(runtime *libpod.Runtime, src string, dest strin
// TODO: We can potentially start the container while // TODO: We can potentially start the container while
// the copy is running, which still allows a race where // the copy is running, which still allows a race where
// malicious code could mess with the symlink. // malicious code could mess with the symlink.
if errors.Cause(err) != libpod.ErrCtrStateInvalid { if errors.Cause(err) != define.ErrCtrStateInvalid {
return err return err
} }
} else if err == nil { } else if err == nil {

3
cmd/podman/exec.go
View File

@ -10,6 +10,7 @@ import (
"github.com/containers/libpod/cmd/podman/libpodruntime" "github.com/containers/libpod/cmd/podman/libpodruntime"
"github.com/containers/libpod/cmd/podman/shared/parse" "github.com/containers/libpod/cmd/podman/shared/parse"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
) )
@ -126,7 +127,7 @@ func execCmd(c *cliconfig.ExecValues) error {
streams.AttachInput = true streams.AttachInput = true
err = ctr.Exec(c.Tty, c.Privileged, envs, cmd, c.User, c.Workdir, streams, c.PreserveFDs) err = ctr.Exec(c.Tty, c.Privileged, envs, cmd, c.User, c.Workdir, streams, c.PreserveFDs)
if errors.Cause(err) == libpod.ErrCtrStateInvalid { if errors.Cause(err) == define.ErrCtrStateInvalid {
exitCode = 126 exitCode = 126
} }

10
cmd/podman/exists.go
View File

@ -1,14 +1,14 @@
package main package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/spf13/cobra"
"os" "os"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra"
) )
var ( var (
@ -113,7 +113,7 @@ func containerExistsCmd(c *cliconfig.ContainerExistsValues) error {
} }
defer runtime.Shutdown(false) defer runtime.Shutdown(false)
if _, err := runtime.LookupContainer(args[0]); err != nil { if _, err := runtime.LookupContainer(args[0]); err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr || err.Error() == "io.podman.ContainerNotFound" { if errors.Cause(err) == define.ErrNoSuchCtr || err.Error() == "io.podman.ContainerNotFound" {
os.Exit(1) os.Exit(1)
} }
return err return err
@ -133,7 +133,7 @@ func podExistsCmd(c *cliconfig.PodExistsValues) error {
defer runtime.Shutdown(false) defer runtime.Shutdown(false)
if _, err := runtime.LookupPod(args[0]); err != nil { if _, err := runtime.LookupPod(args[0]); err != nil {
if errors.Cause(err) == libpod.ErrNoSuchPod || err.Error() == "io.podman.PodNotFound" { if errors.Cause(err) == define.ErrNoSuchPod || err.Error() == "io.podman.PodNotFound" {
os.Exit(1) os.Exit(1)
} }
return err return err

4
cmd/podman/pause.go
View File

@ -4,7 +4,7 @@ import (
"os" "os"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -55,7 +55,7 @@ func pauseCmd(c *cliconfig.PauseValues) error {
} }
ok, failures, err := runtime.PauseContainers(getContext(), c) ok, failures, err := runtime.PauseContainers(getContext(), c)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
if len(c.InputArgs) > 1 { if len(c.InputArgs) > 1 {
exitCode = 125 exitCode = 125
} else { } else {

3
cmd/podman/pod_stats.go
View File

@ -13,6 +13,7 @@ import (
"github.com/containers/buildah/pkg/formats" "github.com/containers/buildah/pkg/formats"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -153,7 +154,7 @@ func podStatsCmd(c *cliconfig.PodStatsValues) error {
for _, p := range pods { for _, p := range pods {
prevStat := getPreviousPodContainerStats(p.ID(), previousPodStats) prevStat := getPreviousPodContainerStats(p.ID(), previousPodStats)
newPodStats, err := p.GetPodStats(prevStat) newPodStats, err := p.GetPodStats(prevStat)
if errors.Cause(err) == libpod.ErrNoSuchPod { if errors.Cause(err) == define.ErrNoSuchPod {
continue continue
} }
if err != nil { if err != nil {

10
cmd/podman/restart.go
View File

@ -2,7 +2,7 @@ package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -39,8 +39,8 @@ func init() {
flags.BoolVarP(&restartCommand.All, "all", "a", false, "Restart all non-running containers") flags.BoolVarP(&restartCommand.All, "all", "a", false, "Restart all non-running containers")
flags.BoolVarP(&restartCommand.Latest, "latest", "l", false, "Act on the latest container podman is aware of") flags.BoolVarP(&restartCommand.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
flags.BoolVar(&restartCommand.Running, "running", false, "Restart only running containers when --all is used") flags.BoolVar(&restartCommand.Running, "running", false, "Restart only running containers when --all is used")
flags.UintVarP(&restartCommand.Timeout, "timeout", "t", libpod.CtrRemoveTimeout, "Seconds to wait for stop before killing the container") flags.UintVarP(&restartCommand.Timeout, "timeout", "t", define.CtrRemoveTimeout, "Seconds to wait for stop before killing the container")
flags.UintVar(&restartCommand.Timeout, "time", libpod.CtrRemoveTimeout, "Seconds to wait for stop before killing the container") flags.UintVar(&restartCommand.Timeout, "time", define.CtrRemoveTimeout, "Seconds to wait for stop before killing the container")
markFlagHiddenForRemoteClient("latest", flags) markFlagHiddenForRemoteClient("latest", flags)
} }
@ -48,7 +48,7 @@ func init() {
func restartCmd(c *cliconfig.RestartValues) error { func restartCmd(c *cliconfig.RestartValues) error {
all := c.All all := c.All
if len(c.InputArgs) < 1 && !c.Latest && !all { if len(c.InputArgs) < 1 && !c.Latest && !all {
return errors.Wrapf(libpod.ErrInvalidArg, "you must provide at least one container name or ID") return errors.Wrapf(define.ErrInvalidArg, "you must provide at least one container name or ID")
} }
runtime, err := adapter.GetRuntime(getContext(), &c.PodmanCommand) runtime, err := adapter.GetRuntime(getContext(), &c.PodmanCommand)
@ -59,7 +59,7 @@ func restartCmd(c *cliconfig.RestartValues) error {
ok, failures, err := runtime.Restart(getContext(), c) ok, failures, err := runtime.Restart(getContext(), c)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
if len(c.InputArgs) > 1 { if len(c.InputArgs) > 1 {
exitCode = 125 exitCode = 125
} else { } else {

4
cmd/podman/rm.go
View File

@ -4,7 +4,7 @@ import (
"fmt" "fmt"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -65,7 +65,7 @@ func rmCmd(c *cliconfig.RmValues) error {
ok, failures, err := runtime.RemoveContainers(getContext(), c) ok, failures, err := runtime.RemoveContainers(getContext(), c)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
if len(c.InputArgs) > 1 { if len(c.InputArgs) > 1 {
exitCode = 125 exitCode = 125
} else { } else {

4
cmd/podman/runlabel.go
View File

@ -10,7 +10,7 @@ import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/libpodruntime" "github.com/containers/libpod/cmd/podman/libpodruntime"
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/containers/libpod/utils" "github.com/containers/libpod/utils"
@ -169,7 +169,7 @@ func runlabelCmd(c *cliconfig.RunlabelValues) error {
name := cmd[i+1] name := cmd[i+1]
ctr, err := runtime.LookupContainer(name) ctr, err := runtime.LookupContainer(name)
if err != nil { if err != nil {
if errors.Cause(err) != libpod.ErrNoSuchCtr { if errors.Cause(err) != define.ErrNoSuchCtr {
logrus.Debugf("Error occurred searching for container %s: %s", name, err.Error()) logrus.Debugf("Error occurred searching for container %s: %s", name, err.Error())
return err return err
} }

3
cmd/podman/shared/container.go
View File

@ -15,6 +15,7 @@ import (
"github.com/containers/image/types" "github.com/containers/image/types"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
@ -824,7 +825,7 @@ func GenerateKube(name string, service bool, r *libpod.Runtime) (*v1.Pod, *v1.Se
podYAML, servicePorts, err = pod.GenerateForKube() podYAML, servicePorts, err = pod.GenerateForKube()
} else { } else {
if len(container.Dependencies()) > 0 { if len(container.Dependencies()) > 0 {
return nil, nil, errors.Wrapf(libpod.ErrNotImplemented, "containers with dependencies") return nil, nil, errors.Wrapf(define.ErrNotImplemented, "containers with dependencies")
} }
podYAML, err = container.GenerateForKube() podYAML, err = container.GenerateForKube()
} }

4
cmd/podman/start.go
View File

@ -2,7 +2,7 @@ package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -62,7 +62,7 @@ func startCmd(c *cliconfig.StartValues) error {
sigProxy := c.SigProxy || attach sigProxy := c.SigProxy || attach
if sigProxy && !attach { if sigProxy && !attach {
return errors.Wrapf(libpod.ErrInvalidArg, "you cannot use sig-proxy without --attach") return errors.Wrapf(define.ErrInvalidArg, "you cannot use sig-proxy without --attach")
} }
runtime, err := adapter.GetRuntime(getContext(), &c.PodmanCommand) runtime, err := adapter.GetRuntime(getContext(), &c.PodmanCommand)

7
cmd/podman/stats.go
View File

@ -12,6 +12,7 @@ import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/libpodruntime" "github.com/containers/libpod/cmd/podman/libpodruntime"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/docker/go-units" "github.com/docker/go-units"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -127,7 +128,7 @@ func statsCmd(c *cliconfig.StatsValues) error {
initialStats, err := ctr.GetContainerStats(&libpod.ContainerStats{}) initialStats, err := ctr.GetContainerStats(&libpod.ContainerStats{})
if err != nil { if err != nil {
// when doing "all", dont worry about containers that are not running // when doing "all", dont worry about containers that are not running
if c.All && errors.Cause(err) == libpod.ErrCtrRemoved || errors.Cause(err) == libpod.ErrNoSuchCtr || errors.Cause(err) == libpod.ErrCtrStateInvalid { if c.All && errors.Cause(err) == define.ErrCtrRemoved || errors.Cause(err) == define.ErrNoSuchCtr || errors.Cause(err) == define.ErrCtrStateInvalid {
continue continue
} }
return err return err
@ -148,7 +149,7 @@ func statsCmd(c *cliconfig.StatsValues) error {
id := ctr.ID() id := ctr.ID()
if _, ok := containerStats[ctr.ID()]; !ok { if _, ok := containerStats[ctr.ID()]; !ok {
initialStats, err := ctr.GetContainerStats(&libpod.ContainerStats{}) initialStats, err := ctr.GetContainerStats(&libpod.ContainerStats{})
if errors.Cause(err) == libpod.ErrCtrRemoved || errors.Cause(err) == libpod.ErrNoSuchCtr || errors.Cause(err) == libpod.ErrCtrStateInvalid { if errors.Cause(err) == define.ErrCtrRemoved || errors.Cause(err) == define.ErrNoSuchCtr || errors.Cause(err) == define.ErrCtrStateInvalid {
// skip dealing with a container that is gone // skip dealing with a container that is gone
continue continue
} }
@ -158,7 +159,7 @@ func statsCmd(c *cliconfig.StatsValues) error {
containerStats[id] = initialStats containerStats[id] = initialStats
} }
stats, err := ctr.GetContainerStats(containerStats[id]) stats, err := ctr.GetContainerStats(containerStats[id])
if err != nil && errors.Cause(err) != libpod.ErrNoSuchCtr { if err != nil && errors.Cause(err) != define.ErrNoSuchCtr {
return err return err
} }
// replace the previous measurement with the current one // replace the previous measurement with the current one

6
cmd/podman/stop.go
View File

@ -2,7 +2,7 @@ package main
import ( import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -40,8 +40,8 @@ func init() {
flags := stopCommand.Flags() flags := stopCommand.Flags()
flags.BoolVarP(&stopCommand.All, "all", "a", false, "Stop all running containers") 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.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.UintVar(&stopCommand.Timeout, "time", define.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") flags.UintVarP(&stopCommand.Timeout, "timeout", "t", define.CtrRemoveTimeout, "Seconds to wait for stop before killing the container")
markFlagHiddenForRemoteClient("latest", flags) markFlagHiddenForRemoteClient("latest", flags)
} }

4
cmd/podman/unpause.go
View File

@ -4,7 +4,7 @@ import (
"os" "os"
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter" "github.com/containers/libpod/pkg/adapter"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/cobra" "github.com/spf13/cobra"
@ -54,7 +54,7 @@ func unpauseCmd(c *cliconfig.UnpauseValues) error {
} }
ok, failures, err := runtime.UnpauseContainers(getContext(), c) ok, failures, err := runtime.UnpauseContainers(getContext(), c)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
if len(c.InputArgs) > 1 { if len(c.InputArgs) > 1 {
exitCode = 125 exitCode = 125
} else { } else {

251
libpod/boltdb_state.go
View File

@ -5,6 +5,7 @@ import (
"strings" "strings"
"sync" "sync"
"github.com/containers/libpod/libpod/define"
bolt "github.com/etcd-io/bbolt" bolt "github.com/etcd-io/bbolt"
jsoniter "github.com/json-iterator/go" jsoniter "github.com/json-iterator/go"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -133,7 +134,7 @@ func (s *BoltState) Close() error {
// Refresh clears container and pod states after a reboot // Refresh clears container and pod states after a reboot
func (s *BoltState) Refresh() error { func (s *BoltState) Refresh() error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
db, err := s.getDBCon() db, err := s.getDBCon()
@ -171,13 +172,13 @@ func (s *BoltState) Refresh() error {
if podBkt == nil { if podBkt == nil {
// This is neither a pod nor a container // This is neither a pod nor a container
// Error out on the dangling ID // Error out on the dangling ID
return errors.Wrapf(ErrInternal, "id %s is not a pod or a container", string(id)) return errors.Wrapf(define.ErrInternal, "id %s is not a pod or a container", string(id))
} }
// Get the state // Get the state
stateBytes := podBkt.Get(stateKey) stateBytes := podBkt.Get(stateKey)
if stateBytes == nil { if stateBytes == nil {
return errors.Wrapf(ErrInternal, "pod %s missing state key", string(id)) return errors.Wrapf(define.ErrInternal, "pod %s missing state key", string(id))
} }
state := new(podState) state := new(podState)
@ -210,7 +211,7 @@ func (s *BoltState) Refresh() error {
stateBytes := ctrBkt.Get(stateKey) stateBytes := ctrBkt.Get(stateKey)
if stateBytes == nil { if stateBytes == nil {
// Badly formatted container bucket // Badly formatted container bucket
return errors.Wrapf(ErrInternal, "container %s missing state in DB", string(id)) return errors.Wrapf(define.ErrInternal, "container %s missing state in DB", string(id))
} }
state := new(ContainerState) state := new(ContainerState)
@ -243,7 +244,7 @@ func (s *BoltState) Refresh() error {
// the database was first initialized // the database was first initialized
func (s *BoltState) GetDBConfig() (*DBConfig, error) { func (s *BoltState) GetDBConfig() (*DBConfig, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
cfg := new(DBConfig) cfg := new(DBConfig)
@ -290,7 +291,7 @@ func (s *BoltState) GetDBConfig() (*DBConfig, error) {
// ValidateDBConfig validates paths in the given runtime against the database // ValidateDBConfig validates paths in the given runtime against the database
func (s *BoltState) ValidateDBConfig(runtime *Runtime) error { func (s *BoltState) ValidateDBConfig(runtime *Runtime) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
db, err := s.getDBCon() db, err := s.getDBCon()
@ -324,11 +325,11 @@ func (s *BoltState) SetNamespace(ns string) error {
// Container retrieves a single container from the state by its full ID // Container retrieves a single container from the state by its full ID
func (s *BoltState) Container(id string) (*Container, error) { func (s *BoltState) Container(id string) (*Container, error) {
if id == "" { if id == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
ctrID := []byte(id) ctrID := []byte(id)
@ -362,11 +363,11 @@ func (s *BoltState) Container(id string) (*Container, error) {
// partial ID or name // partial ID or name
func (s *BoltState) LookupContainer(idOrName string) (*Container, error) { func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
if idOrName == "" { if idOrName == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
ctr := new(Container) ctr := new(Container)
@ -446,7 +447,7 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
} }
if strings.HasPrefix(string(checkID), idOrName) { if strings.HasPrefix(string(checkID), idOrName) {
if exists { if exists {
return errors.Wrapf(ErrCtrExists, "more than one result for container ID %s", idOrName) return errors.Wrapf(define.ErrCtrExists, "more than one result for container ID %s", idOrName)
} }
id = checkID id = checkID
exists = true exists = true
@ -458,9 +459,9 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
return err return err
} else if !exists { } else if !exists {
if isPod { if isPod {
return errors.Wrapf(ErrNoSuchCtr, "%s is a pod, not a container", idOrName) return errors.Wrapf(define.ErrNoSuchCtr, "%s is a pod, not a container", idOrName)
} }
return errors.Wrapf(ErrNoSuchCtr, "no container with name or ID %s found", idOrName) return errors.Wrapf(define.ErrNoSuchCtr, "no container with name or ID %s found", idOrName)
} }
return s.getContainerFromDB(id, ctr, ctrBucket) return s.getContainerFromDB(id, ctr, ctrBucket)
@ -475,11 +476,11 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) {
// HasContainer checks if a container is present in the state // HasContainer checks if a container is present in the state
func (s *BoltState) HasContainer(id string) (bool, error) { func (s *BoltState) HasContainer(id string) (bool, error) {
if id == "" { if id == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return false, ErrDBClosed return false, define.ErrDBClosed
} }
ctrID := []byte(id) ctrID := []byte(id)
@ -523,15 +524,15 @@ func (s *BoltState) HasContainer(id string) (bool, error) {
// The container being added cannot belong to a pod // The container being added cannot belong to a pod
func (s *BoltState) AddContainer(ctr *Container) error { func (s *BoltState) AddContainer(ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
if ctr.config.Pod != "" { if ctr.config.Pod != "" {
return errors.Wrapf(ErrInvalidArg, "cannot add a container that belongs to a pod with AddContainer - use AddContainerToPod") return errors.Wrapf(define.ErrInvalidArg, "cannot add a container that belongs to a pod with AddContainer - use AddContainerToPod")
} }
return s.addContainer(ctr, nil) return s.addContainer(ctr, nil)
@ -542,11 +543,11 @@ func (s *BoltState) AddContainer(ctr *Container) error {
// pod, use RemoveContainerFromPod // pod, use RemoveContainerFromPod
func (s *BoltState) RemoveContainer(ctr *Container) error { func (s *BoltState) RemoveContainer(ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if ctr.config.Pod != "" { if ctr.config.Pod != "" {
return errors.Wrapf(ErrPodExists, "container %s is part of a pod, use RemoveContainerFromPod instead", ctr.ID()) return errors.Wrapf(define.ErrPodExists, "container %s is part of a pod, use RemoveContainerFromPod instead", ctr.ID())
} }
db, err := s.getDBCon() db, err := s.getDBCon()
@ -564,15 +565,15 @@ func (s *BoltState) RemoveContainer(ctr *Container) error {
// UpdateContainer updates a container's state from the database // UpdateContainer updates a container's state from the database
func (s *BoltState) UpdateContainer(ctr *Container) error { func (s *BoltState) UpdateContainer(ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
if s.namespace != "" && s.namespace != ctr.config.Namespace { if s.namespace != "" && s.namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
} }
newState := new(ContainerState) newState := new(ContainerState)
@ -595,12 +596,12 @@ func (s *BoltState) UpdateContainer(ctr *Container) error {
ctrToUpdate := ctrBucket.Bucket(ctrID) ctrToUpdate := ctrBucket.Bucket(ctrID)
if ctrToUpdate == nil { if ctrToUpdate == nil {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in database", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in database", ctr.ID())
} }
newStateBytes := ctrToUpdate.Get(stateKey) newStateBytes := ctrToUpdate.Get(stateKey)
if newStateBytes == nil { if newStateBytes == nil {
return errors.Wrapf(ErrInternal, "container %s does not have a state key in DB", ctr.ID()) return errors.Wrapf(define.ErrInternal, "container %s does not have a state key in DB", ctr.ID())
} }
if err := json.Unmarshal(newStateBytes, newState); err != nil { if err := json.Unmarshal(newStateBytes, newState); err != nil {
@ -632,15 +633,15 @@ func (s *BoltState) UpdateContainer(ctr *Container) error {
// SaveContainer saves a container's current state in the database // SaveContainer saves a container's current state in the database
func (s *BoltState) SaveContainer(ctr *Container) error { func (s *BoltState) SaveContainer(ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
if s.namespace != "" && s.namespace != ctr.config.Namespace { if s.namespace != "" && s.namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
} }
stateJSON, err := json.Marshal(ctr.state) stateJSON, err := json.Marshal(ctr.state)
@ -666,7 +667,7 @@ func (s *BoltState) SaveContainer(ctr *Container) error {
ctrToSave := ctrBucket.Bucket(ctrID) ctrToSave := ctrBucket.Bucket(ctrID)
if ctrToSave == nil { if ctrToSave == nil {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in DB", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in DB", ctr.ID())
} }
// Update the state // Update the state
@ -695,15 +696,15 @@ func (s *BoltState) SaveContainer(ctr *Container) error {
// container. If the slice is empty, no containers depend on the given container // container. If the slice is empty, no containers depend on the given container
func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) { func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
if !ctr.valid { if !ctr.valid {
return nil, ErrCtrRemoved return nil, define.ErrCtrRemoved
} }
if s.namespace != "" && s.namespace != ctr.config.Namespace { if s.namespace != "" && s.namespace != ctr.config.Namespace {
return nil, errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace) return nil, errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
} }
depCtrs := []string{} depCtrs := []string{}
@ -723,12 +724,12 @@ func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
ctrDB := ctrBucket.Bucket([]byte(ctr.ID())) ctrDB := ctrBucket.Bucket([]byte(ctr.ID()))
if ctrDB == nil { if ctrDB == nil {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
} }
dependsBkt := ctrDB.Bucket(dependenciesBkt) dependsBkt := ctrDB.Bucket(dependenciesBkt)
if dependsBkt == nil { if dependsBkt == nil {
return errors.Wrapf(ErrInternal, "container %s has no dependencies bucket", ctr.ID()) return errors.Wrapf(define.ErrInternal, "container %s has no dependencies bucket", ctr.ID())
} }
// Iterate through and add dependencies // Iterate through and add dependencies
@ -754,7 +755,7 @@ func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) {
// AllContainers retrieves all the containers in the database // AllContainers retrieves all the containers in the database
func (s *BoltState) AllContainers() ([]*Container, error) { func (s *BoltState) AllContainers() ([]*Container, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
ctrs := []*Container{} ctrs := []*Container{}
@ -782,7 +783,7 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
// be much less helpful. // be much less helpful.
ctrExists := ctrBucket.Bucket(id) ctrExists := ctrBucket.Bucket(id)
if ctrExists == nil { if ctrExists == nil {
return errors.Wrapf(ErrInternal, "state is inconsistent - container ID %s in all containers, but container not found", string(id)) return errors.Wrapf(define.ErrInternal, "state is inconsistent - container ID %s in all containers, but container not found", string(id))
} }
ctr := new(Container) ctr := new(Container)
@ -794,7 +795,7 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
// ignore it safely. // ignore it safely.
// We just won't include the container in the // We just won't include the container in the
// results. // results.
if errors.Cause(err) != ErrNSMismatch { if errors.Cause(err) != define.ErrNSMismatch {
// Even if it's not an NS mismatch, it's // Even if it's not an NS mismatch, it's
// not worth erroring over. // not worth erroring over.
// If we do, a single bad container JSON // If we do, a single bad container JSON
@ -821,11 +822,11 @@ func (s *BoltState) AllContainers() ([]*Container, error) {
// comment on this function in state.go. // comment on this function in state.go.
func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error { func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
newCfgJSON, err := json.Marshal(newCfg) newCfgJSON, err := json.Marshal(newCfg)
@ -848,7 +849,7 @@ func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConf
ctrDB := ctrBkt.Bucket([]byte(ctr.ID())) ctrDB := ctrBkt.Bucket([]byte(ctr.ID()))
if ctrDB == nil { if ctrDB == nil {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
} }
if err := ctrDB.Put(configKey, newCfgJSON); err != nil { if err := ctrDB.Put(configKey, newCfgJSON); err != nil {
@ -865,11 +866,11 @@ func (s *BoltState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConf
// comment on this function in state.go. // comment on this function in state.go.
func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error { func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
newCfgJSON, err := json.Marshal(newCfg) newCfgJSON, err := json.Marshal(newCfg)
@ -892,7 +893,7 @@ func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
podDB := podBkt.Bucket([]byte(pod.ID())) podDB := podBkt.Bucket([]byte(pod.ID()))
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
} }
if err := podDB.Put(configKey, newCfgJSON); err != nil { if err := podDB.Put(configKey, newCfgJSON); err != nil {
@ -907,11 +908,11 @@ func (s *BoltState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
// Pod retrieves a pod given its full ID // Pod retrieves a pod given its full ID
func (s *BoltState) Pod(id string) (*Pod, error) { func (s *BoltState) Pod(id string) (*Pod, error) {
if id == "" { if id == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
podID := []byte(id) podID := []byte(id)
@ -944,11 +945,11 @@ func (s *BoltState) Pod(id string) (*Pod, error) {
// LookupPod retrieves a pod from full or unique partial ID or name // LookupPod retrieves a pod from full or unique partial ID or name
func (s *BoltState) LookupPod(idOrName string) (*Pod, error) { func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
if idOrName == "" { if idOrName == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
pod := new(Pod) pod := new(Pod)
@ -1025,7 +1026,7 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
} }
if strings.HasPrefix(string(checkID), idOrName) { if strings.HasPrefix(string(checkID), idOrName) {
if exists { if exists {
return errors.Wrapf(ErrPodExists, "more than one result for ID or name %s", idOrName) return errors.Wrapf(define.ErrPodExists, "more than one result for ID or name %s", idOrName)
} }
id = checkID id = checkID
exists = true exists = true
@ -1037,9 +1038,9 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
return err return err
} else if !exists { } else if !exists {
if isCtr { if isCtr {
return errors.Wrapf(ErrNoSuchPod, "%s is a container, not a pod", idOrName) return errors.Wrapf(define.ErrNoSuchPod, "%s is a container, not a pod", idOrName)
} }
return errors.Wrapf(ErrNoSuchPod, "no pod with name or ID %s found", idOrName) return errors.Wrapf(define.ErrNoSuchPod, "no pod with name or ID %s found", idOrName)
} }
// We might have found a container ID, but it's OK // We might have found a container ID, but it's OK
@ -1056,11 +1057,11 @@ func (s *BoltState) LookupPod(idOrName string) (*Pod, error) {
// HasPod checks if a pod with the given ID exists in the state // HasPod checks if a pod with the given ID exists in the state
func (s *BoltState) HasPod(id string) (bool, error) { func (s *BoltState) HasPod(id string) (bool, error) {
if id == "" { if id == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return false, ErrDBClosed return false, define.ErrDBClosed
} }
podID := []byte(id) podID := []byte(id)
@ -1103,19 +1104,19 @@ func (s *BoltState) HasPod(id string) (bool, error) {
// PodHasContainer checks if the given pod has a container with the given ID // PodHasContainer checks if the given pod has a container with the given ID
func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) { func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
if id == "" { if id == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return false, ErrDBClosed return false, define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return false, ErrPodRemoved return false, define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return false, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return false, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
ctrID := []byte(id) ctrID := []byte(id)
@ -1139,13 +1140,13 @@ func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
} }
// Get pod containers bucket // Get pod containers bucket
podCtrs := podDB.Bucket(containersBkt) podCtrs := podDB.Bucket(containersBkt)
if podCtrs == nil { if podCtrs == nil {
return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
} }
// Don't bother with a namespace check on the container - // Don't bother with a namespace check on the container -
@ -1170,15 +1171,15 @@ func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) {
// PodContainersByID returns the IDs of all containers present in the given pod // PodContainersByID returns the IDs of all containers present in the given pod
func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) { func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return nil, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return nil, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
podID := []byte(pod.ID()) podID := []byte(pod.ID())
@ -1201,13 +1202,13 @@ func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
} }
// Get pod containers bucket // Get pod containers bucket
podCtrs := podDB.Bucket(containersBkt) podCtrs := podDB.Bucket(containersBkt)
if podCtrs == nil { if podCtrs == nil {
return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
} }
// Iterate through all containers in the pod // Iterate through all containers in the pod
@ -1232,15 +1233,15 @@ func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) {
// PodContainers returns all the containers present in the given pod // PodContainers returns all the containers present in the given pod
func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) { func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return nil, errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return nil, errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
podID := []byte(pod.ID()) podID := []byte(pod.ID())
@ -1268,13 +1269,13 @@ func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s not found in database", pod.ID())
} }
// Get pod containers bucket // Get pod containers bucket
podCtrs := podDB.Bucket(containersBkt) podCtrs := podDB.Bucket(containersBkt)
if podCtrs == nil { if podCtrs == nil {
return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s missing containers bucket in DB", pod.ID())
} }
// Iterate through all containers in the pod // Iterate through all containers in the pod
@ -1303,11 +1304,11 @@ func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) {
// the sub bucket holding the container dependencies that this volume has // the sub bucket holding the container dependencies that this volume has
func (s *BoltState) AddVolume(volume *Volume) error { func (s *BoltState) AddVolume(volume *Volume) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !volume.valid { if !volume.valid {
return ErrVolumeRemoved return define.ErrVolumeRemoved
} }
volName := []byte(volume.Name()) volName := []byte(volume.Name())
@ -1337,7 +1338,7 @@ func (s *BoltState) AddVolume(volume *Volume) error {
// Check if we already have a volume with the given name // Check if we already have a volume with the given name
volExists := allVolsBkt.Get(volName) volExists := allVolsBkt.Get(volName)
if volExists != nil { if volExists != nil {
return errors.Wrapf(ErrVolumeExists, "name %s is in use", volume.Name()) return errors.Wrapf(define.ErrVolumeExists, "name %s is in use", volume.Name())
} }
// We are good to add the volume // We are good to add the volume
@ -1369,7 +1370,7 @@ func (s *BoltState) AddVolume(volume *Volume) error {
// RemoveVolume removes the given volume from the state // RemoveVolume removes the given volume from the state
func (s *BoltState) RemoveVolume(volume *Volume) error { func (s *BoltState) RemoveVolume(volume *Volume) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
volName := []byte(volume.Name()) volName := []byte(volume.Name())
@ -1400,7 +1401,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
volDB := volBkt.Bucket(volName) volDB := volBkt.Bucket(volName)
if volDB == nil { if volDB == nil {
volume.valid = false volume.valid = false
return errors.Wrapf(ErrNoSuchVolume, "volume %s does not exist in DB", volume.Name()) return errors.Wrapf(define.ErrNoSuchVolume, "volume %s does not exist in DB", volume.Name())
} }
// Check if volume is not being used by any container // Check if volume is not being used by any container
@ -1430,7 +1431,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
return errors.Wrapf(err, "error getting list of dependencies from dependencies bucket for volumes %q", volume.Name()) return errors.Wrapf(err, "error getting list of dependencies from dependencies bucket for volumes %q", volume.Name())
} }
if len(deps) > 0 { if len(deps) > 0 {
return errors.Wrapf(ErrVolumeBeingUsed, "volume %s is being used by container(s) %s", volume.Name(), strings.Join(deps, ",")) return errors.Wrapf(define.ErrVolumeBeingUsed, "volume %s is being used by container(s) %s", volume.Name(), strings.Join(deps, ","))
} }
} }
@ -1451,7 +1452,7 @@ func (s *BoltState) RemoveVolume(volume *Volume) error {
// AllVolumes returns all volumes present in the state // AllVolumes returns all volumes present in the state
func (s *BoltState) AllVolumes() ([]*Volume, error) { func (s *BoltState) AllVolumes() ([]*Volume, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
volumes := []*Volume{} volumes := []*Volume{}
@ -1477,14 +1478,14 @@ func (s *BoltState) AllVolumes() ([]*Volume, error) {
// This check can be removed if performance becomes an // This check can be removed if performance becomes an
// issue, but much less helpful errors will be produced // issue, but much less helpful errors will be produced
if volExists == nil { if volExists == nil {
return errors.Wrapf(ErrInternal, "inconsistency in state - volume %s is in all volumes bucket but volume not found", string(id)) return errors.Wrapf(define.ErrInternal, "inconsistency in state - volume %s is in all volumes bucket but volume not found", string(id))
} }
volume := new(Volume) volume := new(Volume)
volume.config = new(VolumeConfig) volume.config = new(VolumeConfig)
if err := s.getVolumeFromDB(id, volume, volBucket); err != nil { if err := s.getVolumeFromDB(id, volume, volBucket); err != nil {
if errors.Cause(err) != ErrNSMismatch { if errors.Cause(err) != define.ErrNSMismatch {
logrus.Errorf("Error retrieving volume %s from the database: %v", string(id), err) logrus.Errorf("Error retrieving volume %s from the database: %v", string(id), err)
} }
} else { } else {
@ -1505,11 +1506,11 @@ func (s *BoltState) AllVolumes() ([]*Volume, error) {
// Volume retrieves a volume from full name // Volume retrieves a volume from full name
func (s *BoltState) Volume(name string) (*Volume, error) { func (s *BoltState) Volume(name string) (*Volume, error) {
if name == "" { if name == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
volName := []byte(name) volName := []byte(name)
@ -1541,11 +1542,11 @@ func (s *BoltState) Volume(name string) (*Volume, error) {
// HasVolume returns true if the given volume exists in the state, otherwise it returns false // HasVolume returns true if the given volume exists in the state, otherwise it returns false
func (s *BoltState) HasVolume(name string) (bool, error) { func (s *BoltState) HasVolume(name string) (bool, error) {
if name == "" { if name == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
if !s.valid { if !s.valid {
return false, ErrDBClosed return false, define.ErrDBClosed
} }
volName := []byte(name) volName := []byte(name)
@ -1583,11 +1584,11 @@ func (s *BoltState) HasVolume(name string) (bool, error) {
// volume. If the slice is empty, no containers use the given volume // volume. If the slice is empty, no containers use the given volume
func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) { func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
if !volume.valid { if !volume.valid {
return nil, ErrVolumeRemoved return nil, define.ErrVolumeRemoved
} }
depCtrs := []string{} depCtrs := []string{}
@ -1612,12 +1613,12 @@ func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
volDB := volBucket.Bucket([]byte(volume.Name())) volDB := volBucket.Bucket([]byte(volume.Name()))
if volDB == nil { if volDB == nil {
volume.valid = false volume.valid = false
return errors.Wrapf(ErrNoSuchVolume, "no volume with name %s found in DB", volume.Name()) return errors.Wrapf(define.ErrNoSuchVolume, "no volume with name %s found in DB", volume.Name())
} }
dependsBkt := volDB.Bucket(volDependenciesBkt) dependsBkt := volDB.Bucket(volDependenciesBkt)
if dependsBkt == nil { if dependsBkt == nil {
return errors.Wrapf(ErrInternal, "volume %s has no dependencies bucket", volume.Name()) return errors.Wrapf(define.ErrInternal, "volume %s has no dependencies bucket", volume.Name())
} }
// Iterate through and add dependencies // Iterate through and add dependencies
@ -1649,15 +1650,15 @@ func (s *BoltState) VolumeInUse(volume *Volume) ([]string, error) {
// AddPod adds the given pod to the state. // AddPod adds the given pod to the state.
func (s *BoltState) AddPod(pod *Pod) error { func (s *BoltState) AddPod(pod *Pod) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
podID := []byte(pod.ID()) podID := []byte(pod.ID())
@ -1713,11 +1714,11 @@ func (s *BoltState) AddPod(pod *Pod) error {
// Check if we already have something with the given ID and name // Check if we already have something with the given ID and name
idExist := idsBkt.Get(podID) idExist := idsBkt.Get(podID)
if idExist != nil { if idExist != nil {
return errors.Wrapf(ErrPodExists, "ID %s is in use", pod.ID()) return errors.Wrapf(define.ErrPodExists, "ID %s is in use", pod.ID())
} }
nameExist := namesBkt.Get(podName) nameExist := namesBkt.Get(podName)
if nameExist != nil { if nameExist != nil {
return errors.Wrapf(ErrPodExists, "name %s is in use", pod.Name()) return errors.Wrapf(define.ErrPodExists, "name %s is in use", pod.Name())
} }
// We are good to add the pod // We are good to add the pod
@ -1773,15 +1774,15 @@ func (s *BoltState) AddPod(pod *Pod) error {
// Only empty pods can be removed // Only empty pods can be removed
func (s *BoltState) RemovePod(pod *Pod) error { func (s *BoltState) RemovePod(pod *Pod) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
podID := []byte(pod.ID()) podID := []byte(pod.ID())
@ -1823,7 +1824,7 @@ func (s *BoltState) RemovePod(pod *Pod) error {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
} }
// Check if pod is empty // Check if pod is empty
@ -1835,7 +1836,7 @@ func (s *BoltState) RemovePod(pod *Pod) error {
if podCtrsBkt != nil { if podCtrsBkt != nil {
cursor := podCtrsBkt.Cursor() cursor := podCtrsBkt.Cursor()
if id, _ := cursor.First(); id != nil { if id, _ := cursor.First(); id != nil {
return errors.Wrapf(ErrCtrExists, "pod %s is not empty", pod.ID()) return errors.Wrapf(define.ErrCtrExists, "pod %s is not empty", pod.ID())
} }
} }
@ -1869,15 +1870,15 @@ func (s *BoltState) RemovePod(pod *Pod) error {
// RemovePodContainers removes all containers in a pod // RemovePodContainers removes all containers in a pod
func (s *BoltState) RemovePodContainers(pod *Pod) error { func (s *BoltState) RemovePodContainers(pod *Pod) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
podID := []byte(pod.ID()) podID := []byte(pod.ID())
@ -1918,12 +1919,12 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in DB", pod.ID())
} }
podCtrsBkt := podDB.Bucket(containersBkt) podCtrsBkt := podDB.Bucket(containersBkt)
if podCtrsBkt == nil { if podCtrsBkt == nil {
return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s does not have a containers bucket", pod.ID())
} }
// Traverse all containers in the pod with a cursor // Traverse all containers in the pod with a cursor
@ -1934,7 +1935,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
if ctr == nil { if ctr == nil {
// This should never happen // This should never happen
// State is inconsistent // State is inconsistent
return errors.Wrapf(ErrNoSuchCtr, "pod %s referenced nonexistant container %s", pod.ID(), string(id)) return errors.Wrapf(define.ErrNoSuchCtr, "pod %s referenced nonexistant container %s", pod.ID(), string(id))
} }
ctrDeps := ctr.Bucket(dependenciesBkt) ctrDeps := ctr.Bucket(dependenciesBkt)
// This should never be nil, but if it is, we're // This should never be nil, but if it is, we're
@ -1943,7 +1944,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
err = ctrDeps.ForEach(func(depID, name []byte) error { err = ctrDeps.ForEach(func(depID, name []byte) error {
exists := podCtrsBkt.Get(depID) exists := podCtrsBkt.Get(depID)
if exists == nil { if exists == nil {
return errors.Wrapf(ErrCtrExists, "container %s has dependency %s outside of pod %s", string(id), string(depID), pod.ID()) return errors.Wrapf(define.ErrCtrExists, "container %s has dependency %s outside of pod %s", string(id), string(depID), pod.ID())
} }
return nil return nil
}) })
@ -1955,7 +1956,7 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
// Dependencies are set, we're clear to remove // Dependencies are set, we're clear to remove
if err := ctrBkt.DeleteBucket(id); err != nil { if err := ctrBkt.DeleteBucket(id); err != nil {
return errors.Wrapf(ErrInternal, "error deleting container %s from DB", string(id)) return errors.Wrapf(define.ErrInternal, "error deleting container %s from DB", string(id))
} }
if err := idsBkt.Delete(id); err != nil { if err := idsBkt.Delete(id); err != nil {
@ -1997,19 +1998,19 @@ func (s *BoltState) RemovePodContainers(pod *Pod) error {
// The container will be added to the state and the pod // The container will be added to the state and the pod
func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error { func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
if ctr.config.Pod != pod.ID() { if ctr.config.Pod != pod.ID() {
return errors.Wrapf(ErrNoSuchCtr, "container %s is not part of pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container %s is not part of pod %s", ctr.ID(), pod.ID())
} }
return s.addContainer(ctr, pod) return s.addContainer(ctr, pod)
@ -2019,28 +2020,28 @@ func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error {
// The container will also be removed from the state // The container will also be removed from the state
func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error { func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" { if s.namespace != "" {
if s.namespace != pod.config.Namespace { if s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
if s.namespace != ctr.config.Namespace { if s.namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s in in namespace %q but we are in namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s in in namespace %q but we are in namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
} }
} }
if ctr.config.Pod == "" { if ctr.config.Pod == "" {
return errors.Wrapf(ErrNoSuchPod, "container %s is not part of a pod, use RemoveContainer instead", ctr.ID()) return errors.Wrapf(define.ErrNoSuchPod, "container %s is not part of a pod, use RemoveContainer instead", ctr.ID())
} }
if ctr.config.Pod != pod.ID() { if ctr.config.Pod != pod.ID() {
return errors.Wrapf(ErrInvalidArg, "container %s is not part of pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrInvalidArg, "container %s is not part of pod %s", ctr.ID(), pod.ID())
} }
db, err := s.getDBCon() db, err := s.getDBCon()
@ -2058,15 +2059,15 @@ func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
// UpdatePod updates a pod's state from the database // UpdatePod updates a pod's state from the database
func (s *BoltState) UpdatePod(pod *Pod) error { func (s *BoltState) UpdatePod(pod *Pod) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
newState := new(podState) newState := new(podState)
@ -2088,13 +2089,13 @@ func (s *BoltState) UpdatePod(pod *Pod) error {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
} }
// Get the pod state JSON // Get the pod state JSON
podStateBytes := podDB.Get(stateKey) podStateBytes := podDB.Get(stateKey)
if podStateBytes == nil { if podStateBytes == nil {
return errors.Wrapf(ErrInternal, "pod %s is missing state key in DB", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s is missing state key in DB", pod.ID())
} }
if err := json.Unmarshal(podStateBytes, newState); err != nil { if err := json.Unmarshal(podStateBytes, newState); err != nil {
@ -2115,15 +2116,15 @@ func (s *BoltState) UpdatePod(pod *Pod) error {
// SavePod saves a pod's state to the database // SavePod saves a pod's state to the database
func (s *BoltState) SavePod(pod *Pod) error { func (s *BoltState) SavePod(pod *Pod) error {
if !s.valid { if !s.valid {
return ErrDBClosed return define.ErrDBClosed
} }
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if s.namespace != "" && s.namespace != pod.config.Namespace { if s.namespace != "" && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q but we are in namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
stateJSON, err := json.Marshal(pod.state) stateJSON, err := json.Marshal(pod.state)
@ -2148,7 +2149,7 @@ func (s *BoltState) SavePod(pod *Pod) error {
podDB := podBkt.Bucket(podID) podDB := podBkt.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in database", pod.ID())
} }
// Set the pod state JSON // Set the pod state JSON
@ -2168,7 +2169,7 @@ func (s *BoltState) SavePod(pod *Pod) error {
// AllPods returns all pods present in the state // AllPods returns all pods present in the state
func (s *BoltState) AllPods() ([]*Pod, error) { func (s *BoltState) AllPods() ([]*Pod, error) {
if !s.valid { if !s.valid {
return nil, ErrDBClosed return nil, define.ErrDBClosed
} }
pods := []*Pod{} pods := []*Pod{}
@ -2195,7 +2196,7 @@ func (s *BoltState) AllPods() ([]*Pod, error) {
// This check can be removed if performance becomes an // This check can be removed if performance becomes an
// issue, but much less helpful errors will be produced // issue, but much less helpful errors will be produced
if podExists == nil { if podExists == nil {
return errors.Wrapf(ErrInternal, "inconsistency in state - pod %s is in all pods bucket but pod not found", string(id)) return errors.Wrapf(define.ErrInternal, "inconsistency in state - pod %s is in all pods bucket but pod not found", string(id))
} }
pod := new(Pod) pod := new(Pod)
@ -2203,7 +2204,7 @@ func (s *BoltState) AllPods() ([]*Pod, error) {
pod.state = new(podState) pod.state = new(podState)
if err := s.getPodFromDB(id, pod, podBucket); err != nil { if err := s.getPodFromDB(id, pod, podBucket); err != nil {
if errors.Cause(err) != ErrNSMismatch { if errors.Cause(err) != define.ErrNSMismatch {
logrus.Errorf("Error retrieving pod %s from the database: %v", string(id), err) logrus.Errorf("Error retrieving pod %s from the database: %v", string(id), err)
} }
} else { } else {

83
libpod/boltdb_state_internal.go
View File

@ -6,6 +6,7 @@ import (
"runtime" "runtime"
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/containers/storage" "github.com/containers/storage"
bolt "github.com/etcd-io/bbolt" bolt "github.com/etcd-io/bbolt"
@ -222,7 +223,7 @@ func readOnlyValidateConfig(bucket *bolt.Bucket, toCheck dbConfigValidation) (bo
return true, nil return true, nil
} }
return true, errors.Wrapf(ErrDBBadConfig, "database %s %q does not match our %s %q", return true, errors.Wrapf(define.ErrDBBadConfig, "database %s %q does not match our %s %q",
toCheck.name, dbValue, toCheck.name, toCheck.runtimeValue) toCheck.name, dbValue, toCheck.name, toCheck.runtimeValue)
} }
@ -260,7 +261,7 @@ func (s *BoltState) closeDBCon(db *bolt.DB) error {
func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(idRegistryBkt) bkt := tx.Bucket(idRegistryBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "id registry bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "id registry bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -268,7 +269,7 @@ func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(nameRegistryBkt) bkt := tx.Bucket(nameRegistryBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "name registry bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "name registry bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -276,7 +277,7 @@ func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(nsRegistryBkt) bkt := tx.Bucket(nsRegistryBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "namespace registry bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "namespace registry bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -284,7 +285,7 @@ func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(ctrBkt) bkt := tx.Bucket(ctrBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "containers bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "containers bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -292,7 +293,7 @@ func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(allCtrsBkt) bkt := tx.Bucket(allCtrsBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "all containers bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "all containers bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -300,7 +301,7 @@ func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(podBkt) bkt := tx.Bucket(podBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "pods bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "pods bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -308,7 +309,7 @@ func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(allPodsBkt) bkt := tx.Bucket(allPodsBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "all pods bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "all pods bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -316,7 +317,7 @@ func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(volBkt) bkt := tx.Bucket(volBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "volumes bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "volumes bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -324,7 +325,7 @@ func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(allVolsBkt) bkt := tx.Bucket(allVolsBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "all volumes bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "all volumes bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -332,7 +333,7 @@ func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) { func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
bkt := tx.Bucket(runtimeConfigBkt) bkt := tx.Bucket(runtimeConfigBkt)
if bkt == nil { if bkt == nil {
return nil, errors.Wrapf(ErrDBBadConfig, "runtime configuration bucket not found in DB") return nil, errors.Wrapf(define.ErrDBBadConfig, "runtime configuration bucket not found in DB")
} }
return bkt, nil return bkt, nil
} }
@ -341,19 +342,19 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
valid := true valid := true
ctrBkt := ctrsBkt.Bucket(id) ctrBkt := ctrsBkt.Bucket(id)
if ctrBkt == nil { if ctrBkt == nil {
return errors.Wrapf(ErrNoSuchCtr, "container %s not found in DB", string(id)) return errors.Wrapf(define.ErrNoSuchCtr, "container %s not found in DB", string(id))
} }
if s.namespaceBytes != nil { if s.namespaceBytes != nil {
ctrNamespaceBytes := ctrBkt.Get(namespaceKey) ctrNamespaceBytes := ctrBkt.Get(namespaceKey)
if !bytes.Equal(s.namespaceBytes, ctrNamespaceBytes) { if !bytes.Equal(s.namespaceBytes, ctrNamespaceBytes) {
return errors.Wrapf(ErrNSMismatch, "cannot retrieve container %s as it is part of namespace %q and we are in namespace %q", string(id), string(ctrNamespaceBytes), s.namespace) return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve container %s as it is part of namespace %q and we are in namespace %q", string(id), string(ctrNamespaceBytes), s.namespace)
} }
} }
configBytes := ctrBkt.Get(configKey) configBytes := ctrBkt.Get(configKey)
if configBytes == nil { if configBytes == nil {
return errors.Wrapf(ErrInternal, "container %s missing config key in DB", string(id)) return errors.Wrapf(define.ErrInternal, "container %s missing config key in DB", string(id))
} }
if err := json.Unmarshal(configBytes, ctr.config); err != nil { if err := json.Unmarshal(configBytes, ctr.config); err != nil {
@ -379,7 +380,7 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
ociRuntime, ok := s.runtime.ociRuntimes[runtimeName] ociRuntime, ok := s.runtime.ociRuntimes[runtimeName]
if !ok { if !ok {
return errors.Wrapf(ErrInternal, "container %s was created with OCI runtime %s, but that runtime is not available in the current configuration", ctr.ID(), ctr.config.OCIRuntime) return errors.Wrapf(define.ErrInternal, "container %s was created with OCI runtime %s, but that runtime is not available in the current configuration", ctr.ID(), ctr.config.OCIRuntime)
} }
ctr.ociRuntime = ociRuntime ctr.ociRuntime = ociRuntime
} }
@ -393,19 +394,19 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error { func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error {
podDB := podBkt.Bucket(id) podDB := podBkt.Bucket(id)
if podDB == nil { if podDB == nil {
return errors.Wrapf(ErrNoSuchPod, "pod with ID %s not found", string(id)) return errors.Wrapf(define.ErrNoSuchPod, "pod with ID %s not found", string(id))
} }
if s.namespaceBytes != nil { if s.namespaceBytes != nil {
podNamespaceBytes := podDB.Get(namespaceKey) podNamespaceBytes := podDB.Get(namespaceKey)
if !bytes.Equal(s.namespaceBytes, podNamespaceBytes) { if !bytes.Equal(s.namespaceBytes, podNamespaceBytes) {
return errors.Wrapf(ErrNSMismatch, "cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q", string(id), string(podNamespaceBytes), s.namespace) return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q", string(id), string(podNamespaceBytes), s.namespace)
} }
} }
podConfigBytes := podDB.Get(configKey) podConfigBytes := podDB.Get(configKey)
if podConfigBytes == nil { if podConfigBytes == nil {
return errors.Wrapf(ErrInternal, "pod %s is missing configuration key in DB", string(id)) return errors.Wrapf(define.ErrInternal, "pod %s is missing configuration key in DB", string(id))
} }
if err := json.Unmarshal(podConfigBytes, pod.config); err != nil { if err := json.Unmarshal(podConfigBytes, pod.config); err != nil {
@ -428,12 +429,12 @@ func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error
func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bucket) error { func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bucket) error {
volDB := volBkt.Bucket(name) volDB := volBkt.Bucket(name)
if volDB == nil { if volDB == nil {
return errors.Wrapf(ErrNoSuchVolume, "volume with name %s not found", string(name)) return errors.Wrapf(define.ErrNoSuchVolume, "volume with name %s not found", string(name))
} }
volConfigBytes := volDB.Get(configKey) volConfigBytes := volDB.Get(configKey)
if volConfigBytes == nil { if volConfigBytes == nil {
return errors.Wrapf(ErrInternal, "volume %s is missing configuration key in DB", string(name)) return errors.Wrapf(define.ErrInternal, "volume %s is missing configuration key in DB", string(name))
} }
if err := json.Unmarshal(volConfigBytes, volume.config); err != nil { if err := json.Unmarshal(volConfigBytes, volume.config); err != nil {
@ -450,7 +451,7 @@ func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bu
// If pod is not nil, the container is added to the pod as well // If pod is not nil, the container is added to the pod as well
func (s *BoltState) addContainer(ctr *Container, pod *Pod) error { func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
if s.namespace != "" && s.namespace != ctr.config.Namespace { if s.namespace != "" && s.namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "cannot add container %s as it is in namespace %q and we are in namespace %q", return errors.Wrapf(define.ErrNSMismatch, "cannot add container %s as it is in namespace %q and we are in namespace %q",
ctr.ID(), s.namespace, ctr.config.Namespace) ctr.ID(), s.namespace, ctr.config.Namespace)
} }
@ -526,16 +527,16 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
podDB = podBucket.Bucket(podID) podDB = podBucket.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in database", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in database", pod.ID())
} }
podCtrs = podDB.Bucket(containersBkt) podCtrs = podDB.Bucket(containersBkt)
if podCtrs == nil { if podCtrs == nil {
return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID()) return errors.Wrapf(define.ErrInternal, "pod %s does not have a containers bucket", pod.ID())
} }
podNS := podDB.Get(namespaceKey) podNS := podDB.Get(namespaceKey)
if !bytes.Equal(podNS, ctrNamespace) { if !bytes.Equal(podNS, ctrNamespace) {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s", return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace) ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace)
} }
} }
@ -543,11 +544,11 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
// Check if we already have a container with the given ID and name // Check if we already have a container with the given ID and name
idExist := idsBucket.Get(ctrID) idExist := idsBucket.Get(ctrID)
if idExist != nil { if idExist != nil {
return errors.Wrapf(ErrCtrExists, "ID %s is in use", ctr.ID()) return errors.Wrapf(define.ErrCtrExists, "ID %s is in use", ctr.ID())
} }
nameExist := namesBucket.Get(ctrName) nameExist := namesBucket.Get(ctrName)
if nameExist != nil { if nameExist != nil {
return errors.Wrapf(ErrCtrExists, "name %s is in use", ctr.Name()) return errors.Wrapf(define.ErrCtrExists, "name %s is in use", ctr.Name())
} }
// No overlapping containers // No overlapping containers
@ -603,34 +604,34 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
depCtrBkt := ctrBucket.Bucket(depCtrID) depCtrBkt := ctrBucket.Bucket(depCtrID)
if depCtrBkt == nil { if depCtrBkt == nil {
return errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr) return errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr)
} }
depCtrPod := depCtrBkt.Get(podIDKey) depCtrPod := depCtrBkt.Get(podIDKey)
if pod != nil { if pod != nil {
// If we're part of a pod, make sure the dependency is part of the same pod // If we're part of a pod, make sure the dependency is part of the same pod
if depCtrPod == nil { if depCtrPod == nil {
return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is not in pod %s", ctr.ID(), dependsCtr, pod.ID()) return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is not in pod %s", ctr.ID(), dependsCtr, pod.ID())
} }
if string(depCtrPod) != pod.ID() { if string(depCtrPod) != pod.ID() {
return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is in a different pod (%s)", ctr.ID(), dependsCtr, string(depCtrPod)) return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a different pod (%s)", ctr.ID(), dependsCtr, string(depCtrPod))
} }
} else { } else {
// If we're not part of a pod, we cannot depend on containers in a pod // If we're not part of a pod, we cannot depend on containers in a pod
if depCtrPod != nil { if depCtrPod != nil {
return errors.Wrapf(ErrInvalidArg, "container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods", ctr.ID(), dependsCtr) return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods", ctr.ID(), dependsCtr)
} }
} }
depNamespace := depCtrBkt.Get(namespaceKey) depNamespace := depCtrBkt.Get(namespaceKey)
if !bytes.Equal(ctrNamespace, depNamespace) { if !bytes.Equal(ctrNamespace, depNamespace) {
return errors.Wrapf(ErrNSMismatch, "container %s in namespace %q depends on container %s in namespace %q - namespaces must match", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace)) return errors.Wrapf(define.ErrNSMismatch, "container %s in namespace %q depends on container %s in namespace %q - namespaces must match", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace))
} }
depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt) depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt)
if depCtrDependsBkt == nil { if depCtrDependsBkt == nil {
return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", dependsCtr) return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", dependsCtr)
} }
if err := depCtrDependsBkt.Put(ctrID, ctrName); err != nil { if err := depCtrDependsBkt.Put(ctrID, ctrName); err != nil {
return errors.Wrapf(err, "error adding ctr %s as dependency of container %s", ctr.ID(), dependsCtr) return errors.Wrapf(err, "error adding ctr %s as dependency of container %s", ctr.ID(), dependsCtr)
@ -648,7 +649,7 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
for _, vol := range ctr.config.NamedVolumes { for _, vol := range ctr.config.NamedVolumes {
volDB := volBkt.Bucket([]byte(vol.Name)) volDB := volBkt.Bucket([]byte(vol.Name))
if volDB == nil { if volDB == nil {
return errors.Wrapf(ErrNoSuchVolume, "no volume with name %s found in database when adding container %s", vol.Name, ctr.ID()) return errors.Wrapf(define.ErrNoSuchVolume, "no volume with name %s found in database when adding container %s", vol.Name, ctr.ID())
} }
ctrDepsBkt := volDB.Bucket(volDependenciesBkt) ctrDepsBkt := volDB.Bucket(volDependenciesBkt)
@ -714,7 +715,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
podDB = podBucket.Bucket(podID) podDB = podBucket.Bucket(podID)
if podDB == nil { if podDB == nil {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
} }
} }
@ -722,17 +723,17 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
ctrExists := ctrBucket.Bucket(ctrID) ctrExists := ctrBucket.Bucket(ctrID)
if ctrExists == nil { if ctrExists == nil {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
} }
// Compare namespace // Compare namespace
// We can't remove containers not in our namespace // We can't remove containers not in our namespace
if s.namespace != "" { if s.namespace != "" {
if s.namespace != ctr.config.Namespace { if s.namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
} }
if pod != nil && s.namespace != pod.config.Namespace { if pod != nil && s.namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "pod %s is in namespace %q, does not match out namespace %q", pod.ID(), pod.config.Namespace, s.namespace) return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q, does not match out namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
} }
} }
@ -745,7 +746,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
} else { } else {
ctrInPod := podCtrs.Get(ctrID) ctrInPod := podCtrs.Get(ctrID)
if ctrInPod == nil { if ctrInPod == nil {
return errors.Wrapf(ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID())
} }
if err := podCtrs.Delete(ctrID); err != nil { if err := podCtrs.Delete(ctrID); err != nil {
return errors.Wrapf(err, "error removing container %s from pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(err, "error removing container %s from pod %s", ctr.ID(), pod.ID())
@ -756,7 +757,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
// Does the container have dependencies? // Does the container have dependencies?
ctrDepsBkt := ctrExists.Bucket(dependenciesBkt) ctrDepsBkt := ctrExists.Bucket(dependenciesBkt)
if ctrDepsBkt == nil { if ctrDepsBkt == nil {
return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", ctr.ID()) return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", ctr.ID())
} }
deps := []string{} deps := []string{}
err = ctrDepsBkt.ForEach(func(id, value []byte) error { err = ctrDepsBkt.ForEach(func(id, value []byte) error {
@ -768,11 +769,11 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
return err return err
} }
if len(deps) != 0 { if len(deps) != 0 {
return errors.Wrapf(ErrCtrExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", ")) return errors.Wrapf(define.ErrCtrExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", "))
} }
if err := ctrBucket.DeleteBucket(ctrID); err != nil { if err := ctrBucket.DeleteBucket(ctrID); err != nil {
return errors.Wrapf(ErrInternal, "error deleting container %s from DB", ctr.ID()) return errors.Wrapf(define.ErrInternal, "error deleting container %s from DB", ctr.ID())
} }
if err := idsBucket.Delete(ctrID); err != nil { if err := idsBucket.Delete(ctrID); err != nil {

15
libpod/container.go
View File

@ -11,6 +11,7 @@ import (
"github.com/containernetworking/cni/pkg/types" "github.com/containernetworking/cni/pkg/types"
cnitypes "github.com/containernetworking/cni/pkg/types/current" cnitypes "github.com/containernetworking/cni/pkg/types/current"
"github.com/containers/image/manifest" "github.com/containers/image/manifest"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/lock" "github.com/containers/libpod/libpod/lock"
"github.com/containers/libpod/pkg/namespaces" "github.com/containers/libpod/pkg/namespaces"
"github.com/containers/storage" "github.com/containers/storage"
@ -463,7 +464,7 @@ func StringToContainerStatus(status string) (ContainerStatus, error) {
case ContainerStateExited.String(): case ContainerStateExited.String():
return ContainerStateExited, nil return ContainerStateExited, nil
default: default:
return ContainerStateUnknown, errors.Wrapf(ErrInvalidArg, "unknown container state: %s", status) return ContainerStateUnknown, errors.Wrapf(define.ErrInvalidArg, "unknown container state: %s", status)
} }
} }
@ -962,7 +963,7 @@ func (c *Container) ExecSession(id string) (*ExecSession, error) {
session, ok := c.state.ExecSessions[id] session, ok := c.state.ExecSessions[id]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchCtr, "no exec session with ID %s found in container %s", id, c.ID()) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no exec session with ID %s found in container %s", id, c.ID())
} }
returnSession := new(ExecSession) returnSession := new(ExecSession)
@ -987,7 +988,7 @@ func (c *Container) IPs() ([]net.IPNet, error) {
} }
if !c.config.CreateNetNS { if !c.config.CreateNetNS {
return nil, errors.Wrapf(ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID()) return nil, errors.Wrapf(define.ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
} }
ips := make([]net.IPNet, 0) ips := make([]net.IPNet, 0)
@ -1015,7 +1016,7 @@ func (c *Container) Routes() ([]types.Route, error) {
} }
if !c.config.CreateNetNS { if !c.config.CreateNetNS {
return nil, errors.Wrapf(ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID()) return nil, errors.Wrapf(define.ErrInvalidArg, "container %s network namespace is not managed by libpod", c.ID())
} }
routes := make([]types.Route, 0) routes := make([]types.Route, 0)
@ -1092,11 +1093,11 @@ func (c *Container) NamespacePath(ns LinuxNS) (string, error) {
} }
if c.state.State != ContainerStateRunning && c.state.State != ContainerStatePaused { if c.state.State != ContainerStateRunning && c.state.State != ContainerStatePaused {
return "", errors.Wrapf(ErrCtrStopped, "cannot get namespace path unless container %s is running", c.ID()) return "", errors.Wrapf(define.ErrCtrStopped, "cannot get namespace path unless container %s is running", c.ID())
} }
if ns == InvalidNS { if ns == InvalidNS {
return "", errors.Wrapf(ErrInvalidArg, "invalid namespace requested from container %s", c.ID()) return "", errors.Wrapf(define.ErrInvalidArg, "invalid namespace requested from container %s", c.ID())
} }
return fmt.Sprintf("/proc/%d/ns/%s", c.state.PID, ns.String()), nil return fmt.Sprintf("/proc/%d/ns/%s", c.state.PID, ns.String()), nil
@ -1110,7 +1111,7 @@ func (c *Container) CGroupPath() (string, error) {
case SystemdCgroupsManager: case SystemdCgroupsManager:
return filepath.Join(c.config.CgroupParent, createUnitName("libpod", c.ID())), nil return filepath.Join(c.config.CgroupParent, createUnitName("libpod", c.ID())), nil
default: default:
return "", errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager %s in use", c.runtime.config.CgroupManager) return "", errors.Wrapf(define.ErrInvalidArg, "unsupported CGroup manager %s in use", c.runtime.config.CgroupManager)
} }
} }

37
libpod/container_api.go
View File

@ -10,6 +10,7 @@ import (
"sync" "sync"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/pkg/lookup" "github.com/containers/libpod/pkg/lookup"
"github.com/containers/storage/pkg/stringid" "github.com/containers/storage/pkg/stringid"
@ -39,7 +40,7 @@ func (c *Container) Init(ctx context.Context) (err error) {
if !(c.state.State == ContainerStateConfigured || if !(c.state.State == ContainerStateConfigured ||
c.state.State == ContainerStateStopped || c.state.State == ContainerStateStopped ||
c.state.State == ContainerStateExited) { c.state.State == ContainerStateExited) {
return errors.Wrapf(ErrCtrStateInvalid, "container %s has already been created in runtime", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has already been created in runtime", c.ID())
} }
// don't recursively start // don't recursively start
@ -180,12 +181,12 @@ func (c *Container) StopWithTimeout(timeout uint) error {
if c.state.State == ContainerStateConfigured || if c.state.State == ContainerStateConfigured ||
c.state.State == ContainerStateUnknown || c.state.State == ContainerStateUnknown ||
c.state.State == ContainerStatePaused { c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "can only stop created, running, or stopped containers. %s is in state %s", c.ID(), c.state.State.String()) return errors.Wrapf(define.ErrCtrStateInvalid, "can only stop created, running, or stopped containers. %s is in state %s", c.ID(), c.state.State.String())
} }
if c.state.State == ContainerStateStopped || if c.state.State == ContainerStateStopped ||
c.state.State == ContainerStateExited { c.state.State == ContainerStateExited {
return ErrCtrStopped return define.ErrCtrStopped
} }
defer c.newContainerEvent(events.Stop) defer c.newContainerEvent(events.Stop)
return c.stop(timeout) return c.stop(timeout)
@ -203,7 +204,7 @@ func (c *Container) Kill(signal uint) error {
} }
if c.state.State != ContainerStateRunning { if c.state.State != ContainerStateRunning {
return errors.Wrapf(ErrCtrStateInvalid, "can only kill running containers. %s is in state %s", c.ID(), c.state.State.String()) return errors.Wrapf(define.ErrCtrStateInvalid, "can only kill running containers. %s is in state %s", c.ID(), c.state.State.String())
} }
defer c.newContainerEvent(events.Kill) defer c.newContainerEvent(events.Kill)
@ -241,7 +242,7 @@ func (c *Container) Exec(tty, privileged bool, env, cmd []string, user, workDir
// TODO can probably relax this once we track exec sessions // TODO can probably relax this once we track exec sessions
if conState != ContainerStateRunning { if conState != ContainerStateRunning {
return errors.Wrapf(ErrCtrStateInvalid, "cannot exec into container that is not running") return errors.Wrapf(define.ErrCtrStateInvalid, "cannot exec into container that is not running")
} }
if privileged || c.config.Privileged { if privileged || c.config.Privileged {
capList = caps.GetAllCapabilities() capList = caps.GetAllCapabilities()
@ -401,7 +402,7 @@ func (c *Container) Attach(streams *AttachStreams, keys string, resize <-chan re
if c.state.State != ContainerStateCreated && if c.state.State != ContainerStateCreated &&
c.state.State != ContainerStateRunning && c.state.State != ContainerStateRunning &&
c.state.State != ContainerStateExited { c.state.State != ContainerStateExited {
return errors.Wrapf(ErrCtrStateInvalid, "can only attach to created or running containers") return errors.Wrapf(define.ErrCtrStateInvalid, "can only attach to created or running containers")
} }
defer c.newContainerEvent(events.Attach) defer c.newContainerEvent(events.Attach)
return c.attach(streams, keys, resize, false, nil) return c.attach(streams, keys, resize, false, nil)
@ -440,12 +441,12 @@ func (c *Container) Unmount(force bool) error {
} }
if mounted == 1 { if mounted == 1 {
if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused { if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "cannot unmount storage for container %s as it is running or paused", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "cannot unmount storage for container %s as it is running or paused", c.ID())
} }
if len(c.state.ExecSessions) != 0 { if len(c.state.ExecSessions) != 0 {
return errors.Wrapf(ErrCtrStateInvalid, "container %s has active exec sessions, refusing to unmount", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has active exec sessions, refusing to unmount", c.ID())
} }
return errors.Wrapf(ErrInternal, "can't unmount %s last mount, it is still in use", c.ID()) return errors.Wrapf(define.ErrInternal, "can't unmount %s last mount, it is still in use", c.ID())
} }
} }
defer c.newContainerEvent(events.Unmount) defer c.newContainerEvent(events.Unmount)
@ -464,10 +465,10 @@ func (c *Container) Pause() error {
} }
if c.state.State == ContainerStatePaused { if c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "%q is already paused", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "%q is already paused", c.ID())
} }
if c.state.State != ContainerStateRunning { if c.state.State != ContainerStateRunning {
return errors.Wrapf(ErrCtrStateInvalid, "%q is not running, can't pause", c.state.State) return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not running, can't pause", c.state.State)
} }
defer c.newContainerEvent(events.Pause) defer c.newContainerEvent(events.Pause)
return c.pause() return c.pause()
@ -485,7 +486,7 @@ func (c *Container) Unpause() error {
} }
if c.state.State != ContainerStatePaused { if c.state.State != ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "%q is not paused, can't unpause", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not paused, can't unpause", c.ID())
} }
defer c.newContainerEvent(events.Unpause) defer c.newContainerEvent(events.Unpause)
return c.unpause() return c.unpause()
@ -509,7 +510,7 @@ func (c *Container) Export(path string) error {
// AddArtifact creates and writes to an artifact file for the container // AddArtifact creates and writes to an artifact file for the container
func (c *Container) AddArtifact(name string, data []byte) error { func (c *Container) AddArtifact(name string, data []byte) error {
if !c.valid { if !c.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
return ioutil.WriteFile(c.getArtifactPath(name), data, 0740) return ioutil.WriteFile(c.getArtifactPath(name), data, 0740)
@ -518,7 +519,7 @@ func (c *Container) AddArtifact(name string, data []byte) error {
// GetArtifact reads the specified artifact file from the container // GetArtifact reads the specified artifact file from the container
func (c *Container) GetArtifact(name string) ([]byte, error) { func (c *Container) GetArtifact(name string) ([]byte, error) {
if !c.valid { if !c.valid {
return nil, ErrCtrRemoved return nil, define.ErrCtrRemoved
} }
return ioutil.ReadFile(c.getArtifactPath(name)) return ioutil.ReadFile(c.getArtifactPath(name))
@ -527,7 +528,7 @@ func (c *Container) GetArtifact(name string) ([]byte, error) {
// RemoveArtifact deletes the specified artifacts file // RemoveArtifact deletes the specified artifacts file
func (c *Container) RemoveArtifact(name string) error { func (c *Container) RemoveArtifact(name string) error {
if !c.valid { if !c.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
return os.Remove(c.getArtifactPath(name)) return os.Remove(c.getArtifactPath(name))
@ -542,7 +543,7 @@ func (c *Container) Wait() (int32, error) {
// code. The argument is the interval at which checks the container's status. // code. The argument is the interval at which checks the container's status.
func (c *Container) WaitWithInterval(waitTimeout time.Duration) (int32, error) { func (c *Container) WaitWithInterval(waitTimeout time.Duration) (int32, error) {
if !c.valid { if !c.valid {
return -1, ErrCtrRemoved return -1, define.ErrCtrRemoved
} }
err := wait.PollImmediateInfinite(waitTimeout, err := wait.PollImmediateInfinite(waitTimeout,
func() (bool, error) { func() (bool, error) {
@ -578,7 +579,7 @@ func (c *Container) Cleanup(ctx context.Context) error {
// Check if state is good // Check if state is good
if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused { if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "container %s is running or paused, refusing to clean up", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is running or paused, refusing to clean up", c.ID())
} }
// Handle restart policy. // Handle restart policy.
@ -596,7 +597,7 @@ func (c *Container) Cleanup(ctx context.Context) error {
// Check if we have active exec sessions // Check if we have active exec sessions
if len(c.state.ExecSessions) != 0 { if len(c.state.ExecSessions) != 0 {
return errors.Wrapf(ErrCtrStateInvalid, "container %s has active exec sessions, refusing to clean up", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s has active exec sessions, refusing to clean up", c.ID())
} }
defer c.newContainerEvent(events.Cleanup) defer c.newContainerEvent(events.Cleanup)
return c.cleanup(ctx) return c.cleanup(ctx)

7
libpod/container_attach_linux.go
View File

@ -10,6 +10,7 @@ import (
"path/filepath" "path/filepath"
"sync" "sync"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/kubeutils" "github.com/containers/libpod/pkg/kubeutils"
"github.com/containers/libpod/utils" "github.com/containers/libpod/utils"
"github.com/docker/docker/pkg/term" "github.com/docker/docker/pkg/term"
@ -34,7 +35,7 @@ const (
// Does not check if state is appropriate // Does not check if state is appropriate
func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error { func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error {
if !streams.AttachOutput && !streams.AttachError && !streams.AttachInput { if !streams.AttachOutput && !streams.AttachError && !streams.AttachInput {
return errors.Wrapf(ErrInvalidArg, "must provide at least one stream to attach to") return errors.Wrapf(define.ErrInvalidArg, "must provide at least one stream to attach to")
} }
// Check the validity of the provided keys first // Check the validity of the provided keys first
@ -57,7 +58,7 @@ func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan re
// TODO add a channel to allow interrupting // TODO add a channel to allow interrupting
func (c *Container) attachContainerSocket(resize <-chan remotecommand.TerminalSize, detachKeys []byte, streams *AttachStreams, startContainer bool, wg *sync.WaitGroup) error { func (c *Container) attachContainerSocket(resize <-chan remotecommand.TerminalSize, detachKeys []byte, streams *AttachStreams, startContainer bool, wg *sync.WaitGroup) error {
if startContainer && wg == nil { if startContainer && wg == nil {
return errors.Wrapf(ErrInternal, "wait group not passed when startContainer set") return errors.Wrapf(define.ErrInternal, "wait group not passed when startContainer set")
} }
kubeutils.HandleResizing(resize, func(size remotecommand.TerminalSize) { kubeutils.HandleResizing(resize, func(size remotecommand.TerminalSize) {
@ -118,7 +119,7 @@ func (c *Container) attachContainerSocket(resize <-chan remotecommand.TerminalSi
case err := <-receiveStdoutError: case err := <-receiveStdoutError:
return err return err
case err := <-stdinDone: case err := <-stdinDone:
if err == ErrDetach { if err == define.ErrDetach {
return err return err
} }
if streams.AttachOutput || streams.AttachError { if streams.AttachOutput || streams.AttachError {

3
libpod/container_attach_unsupported.go
View File

@ -5,9 +5,10 @@ package libpod
import ( import (
"sync" "sync"
"github.com/containers/libpod/libpod/define"
"k8s.io/client-go/tools/remotecommand" "k8s.io/client-go/tools/remotecommand"
) )
func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error { func (c *Container) attach(streams *AttachStreams, keys string, resize <-chan remotecommand.TerminalSize, startContainer bool, wg *sync.WaitGroup) error {
return ErrNotImplemented return define.ErrNotImplemented
} }

3
libpod/container_commit.go
View File

@ -28,9 +28,6 @@ type ContainerCommitOptions struct {
Changes []string Changes []string
} }
// ChangeCmds is the list of valid Changes commands to passed to the Commit call
var ChangeCmds = []string{"CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"}
// Commit commits the changes between a container and its image, creating a new // Commit commits the changes between a container and its image, creating a new
// image // image
func (c *Container) Commit(ctx context.Context, destImage string, options ContainerCommitOptions) (*image.Image, error) { func (c *Container) Commit(ctx context.Context, destImage string, options ContainerCommitOptions) (*image.Image, error) {

13
libpod/container_graph.go
View File

@ -4,6 +4,7 @@ import (
"context" "context"
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
@ -43,7 +44,7 @@ func buildContainerGraph(ctrs []*Container) (*containerGraph, error) {
// Get the dep's node // Get the dep's node
depNode, ok := graph.nodes[dep] depNode, ok := graph.nodes[dep]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s not found in input list", node.id, dep) return nil, errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s not found in input list", node.id, dep)
} }
// Add the dependent node to the node's dependencies // Add the dependent node to the node's dependencies
@ -68,7 +69,7 @@ func buildContainerGraph(ctrs []*Container) (*containerGraph, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} else if cycle { } else if cycle {
return nil, errors.Wrapf(ErrInternal, "cycle found in container dependency graph") return nil, errors.Wrapf(define.ErrInternal, "cycle found in container dependency graph")
} }
return graph, nil return graph, nil
@ -133,7 +134,7 @@ func detectCycles(graph *containerGraph) (bool, error) {
if info.lowLink == info.index { if info.lowLink == info.index {
l := len(stack) l := len(stack)
if l == 0 { if l == 0 {
return false, errors.Wrapf(ErrInternal, "empty stack in detectCycles") return false, errors.Wrapf(define.ErrInternal, "empty stack in detectCycles")
} }
// Pop off the stack // Pop off the stack
@ -143,7 +144,7 @@ func detectCycles(graph *containerGraph) (bool, error) {
// Popped item is no longer on the stack, mark as such // Popped item is no longer on the stack, mark as such
topInfo, ok := nodes[topOfStack.id] topInfo, ok := nodes[topOfStack.id]
if !ok { if !ok {
return false, errors.Wrapf(ErrInternal, "error finding node info for %s", topOfStack.id) return false, errors.Wrapf(define.ErrInternal, "error finding node info for %s", topOfStack.id)
} }
topInfo.onStack = false topInfo.onStack = false
@ -186,7 +187,7 @@ func startNode(ctx context.Context, node *containerNode, setError bool, ctrError
if setError { if setError {
// Mark us as visited, and set an error // Mark us as visited, and set an error
ctrsVisited[node.id] = true ctrsVisited[node.id] = true
ctrErrors[node.id] = errors.Wrapf(ErrCtrStateInvalid, "a dependency of container %s failed to start", node.id) ctrErrors[node.id] = errors.Wrapf(define.ErrCtrStateInvalid, "a dependency of container %s failed to start", node.id)
// Hit anyone who depends on us, and set errors on them too // Hit anyone who depends on us, and set errors on them too
for _, successor := range node.dependedOn { for _, successor := range node.dependedOn {
@ -226,7 +227,7 @@ func startNode(ctx context.Context, node *containerNode, setError bool, ctrError
} else if len(depsStopped) > 0 { } else if len(depsStopped) > 0 {
// Our dependencies are not running // Our dependencies are not running
depsList := strings.Join(depsStopped, ",") depsList := strings.Join(depsStopped, ",")
ctrErrors[node.id] = errors.Wrapf(ErrCtrStateInvalid, "the following dependencies of container %s are not running: %s", node.id, depsList) ctrErrors[node.id] = errors.Wrapf(define.ErrCtrStateInvalid, "the following dependencies of container %s are not running: %s", node.id, depsList)
ctrErrored = true ctrErrored = true
} }

39
libpod/container_internal.go
View File

@ -12,6 +12,7 @@ import (
"strings" "strings"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/pkg/ctime" "github.com/containers/libpod/pkg/ctime"
"github.com/containers/libpod/pkg/hooks" "github.com/containers/libpod/pkg/hooks"
@ -23,7 +24,7 @@ import (
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/opencontainers/runtime-tools/generate" "github.com/opencontainers/runtime-tools/generate"
"github.com/opencontainers/selinux/go-selinux/label" "github.com/opencontainers/selinux/go-selinux/label"
opentracing "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
@ -243,7 +244,7 @@ func (c *Container) handleRestartPolicy(ctx context.Context) (restarted bool, er
if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused { if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
return false, nil return false, nil
} else if c.state.State == ContainerStateUnknown { } else if c.state.State == ContainerStateUnknown {
return false, errors.Wrapf(ErrInternal, "invalid container state encountered in restart attempt!") return false, errors.Wrapf(define.ErrInternal, "invalid container state encountered in restart attempt!")
} }
c.newContainerEvent(events.Restart) c.newContainerEvent(events.Restart)
@ -319,7 +320,7 @@ func (c *Container) syncContainer() error {
} }
if !c.valid { if !c.valid {
return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", c.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", c.ID())
} }
return nil return nil
@ -332,16 +333,16 @@ func (c *Container) setupStorage(ctx context.Context) error {
defer span.Finish() defer span.Finish()
if !c.valid { if !c.valid {
return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", c.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", c.ID())
} }
if c.state.State != ContainerStateConfigured { if c.state.State != ContainerStateConfigured {
return errors.Wrapf(ErrCtrStateInvalid, "container %s must be in Configured state to have storage set up", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s must be in Configured state to have storage set up", c.ID())
} }
// Need both an image ID and image name, plus a bool telling us whether to use the image configuration // Need both an image ID and image name, plus a bool telling us whether to use the image configuration
if c.config.Rootfs == "" && (c.config.RootfsImageID == "" || c.config.RootfsImageName == "") { if c.config.Rootfs == "" && (c.config.RootfsImageID == "" || c.config.RootfsImageName == "") {
return errors.Wrapf(ErrInvalidArg, "must provide image ID and image name to use an image") return errors.Wrapf(define.ErrInvalidArg, "must provide image ID and image name to use an image")
} }
options := storage.ContainerOptions{ options := storage.ContainerOptions{
@ -418,7 +419,7 @@ func (c *Container) setupStorage(ctx context.Context) error {
// Tear down a container's storage prior to removal // Tear down a container's storage prior to removal
func (c *Container) teardownStorage() error { func (c *Container) teardownStorage() error {
if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused { if c.state.State == ContainerStateRunning || c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "cannot remove storage for container %s as it is running or paused", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove storage for container %s as it is running or paused", c.ID())
} }
artifacts := filepath.Join(c.config.StaticDir, artifactsDir) artifacts := filepath.Join(c.config.StaticDir, artifactsDir)
@ -478,7 +479,7 @@ func (c *Container) refresh() error {
} }
if !c.valid { if !c.valid {
return errors.Wrapf(ErrCtrRemoved, "container %s is not valid - may have been removed", c.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid - may have been removed", c.ID())
} }
// We need to get the container's temporary directory from c/storage // We need to get the container's temporary directory from c/storage
@ -628,7 +629,7 @@ func (c *Container) prepareToStart(ctx context.Context, recursive bool) (err err
c.state.State == ContainerStateCreated || c.state.State == ContainerStateCreated ||
c.state.State == ContainerStateStopped || c.state.State == ContainerStateStopped ||
c.state.State == ContainerStateExited) { c.state.State == ContainerStateExited) {
return errors.Wrapf(ErrCtrStateInvalid, "container %s must be in Created or Stopped state to be started", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s must be in Created or Stopped state to be started", c.ID())
} }
if !recursive { if !recursive {
@ -676,7 +677,7 @@ func (c *Container) checkDependenciesAndHandleError(ctx context.Context) error {
} }
if len(notRunning) > 0 { if len(notRunning) > 0 {
depString := strings.Join(notRunning, ",") depString := strings.Join(notRunning, ",")
return errors.Wrapf(ErrCtrStateInvalid, "some dependencies of container %s are not started: %s", c.ID(), depString) return errors.Wrapf(define.ErrCtrStateInvalid, "some dependencies of container %s are not started: %s", c.ID(), depString)
} }
return nil return nil
@ -714,7 +715,7 @@ func (c *Container) startDependencies(ctx context.Context) error {
if len(graph.nodes) == 0 { if len(graph.nodes) == 0 {
return nil return nil
} }
return errors.Wrapf(ErrNoSuchCtr, "All dependencies have dependencies of %s", c.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "All dependencies have dependencies of %s", c.ID())
} }
ctrErrors := make(map[string]error) ctrErrors := make(map[string]error)
@ -730,7 +731,7 @@ func (c *Container) startDependencies(ctx context.Context) error {
for _, e := range ctrErrors { for _, e := range ctrErrors {
logrus.Errorf("%q", e) logrus.Errorf("%q", e)
} }
return errors.Wrapf(ErrInternal, "error starting some containers") return errors.Wrapf(define.ErrInternal, "error starting some containers")
} }
return nil return nil
} }
@ -816,7 +817,7 @@ func (c *Container) checkDependenciesRunningLocked(depCtrs map[string]*Container
for _, dep := range deps { for _, dep := range deps {
depCtr, ok := depCtrs[dep] depCtr, ok := depCtrs[dep]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s but it is not on containers passed to checkDependenciesRunning", c.ID(), dep) return nil, errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s but it is not on containers passed to checkDependenciesRunning", c.ID(), dep)
} }
if err := c.syncContainer(); err != nil { if err := c.syncContainer(); err != nil {
@ -964,7 +965,7 @@ func (c *Container) reinit(ctx context.Context, retainRetries bool) error {
func (c *Container) initAndStart(ctx context.Context) (err error) { func (c *Container) initAndStart(ctx context.Context) (err error) {
// If we are ContainerStateUnknown, throw an error // If we are ContainerStateUnknown, throw an error
if c.state.State == ContainerStateUnknown { if c.state.State == ContainerStateUnknown {
return errors.Wrapf(ErrCtrStateInvalid, "container %s is in an unknown state", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is in an unknown state", c.ID())
} }
// If we are running, do nothing // If we are running, do nothing
@ -973,7 +974,7 @@ func (c *Container) initAndStart(ctx context.Context) (err error) {
} }
// If we are paused, throw an error // If we are paused, throw an error
if c.state.State == ContainerStatePaused { if c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "cannot start paused container %s", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "cannot start paused container %s", c.ID())
} }
defer func() { defer func() {
@ -1080,7 +1081,7 @@ func (c *Container) unpause() error {
// Internal, non-locking function to restart a container // Internal, non-locking function to restart a container
func (c *Container) restartWithTimeout(ctx context.Context, timeout uint) (err error) { func (c *Container) restartWithTimeout(ctx context.Context, timeout uint) (err error) {
if c.state.State == ContainerStateUnknown || c.state.State == ContainerStatePaused { if c.state.State == ContainerStateUnknown || c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "unable to restart a container in a paused or unknown state") return errors.Wrapf(define.ErrCtrStateInvalid, "unable to restart a container in a paused or unknown state")
} }
c.newContainerEvent(events.Restart) c.newContainerEvent(events.Restart)
@ -1489,16 +1490,16 @@ func (c *Container) copyWithTarFromImage(src, dest string) error {
// Returns nil if safe to remove, or an error describing why it's unsafe if not. // Returns nil if safe to remove, or an error describing why it's unsafe if not.
func (c *Container) checkReadyForRemoval() error { func (c *Container) checkReadyForRemoval() error {
if c.state.State == ContainerStateUnknown { if c.state.State == ContainerStateUnknown {
return errors.Wrapf(ErrCtrStateInvalid, "container %s is in invalid state", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is in invalid state", c.ID())
} }
if c.state.State == ContainerStateRunning || if c.state.State == ContainerStateRunning ||
c.state.State == ContainerStatePaused { c.state.State == ContainerStatePaused {
return errors.Wrapf(ErrCtrStateInvalid, "cannot remove container %s as it is %s - running or paused containers cannot be removed", c.ID(), c.state.State.String()) return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove container %s as it is %s - running or paused containers cannot be removed", c.ID(), c.state.State.String())
} }
if len(c.state.ExecSessions) != 0 { if len(c.state.ExecSessions) != 0 {
return errors.Wrapf(ErrCtrStateInvalid, "cannot remove container %s as it has active exec sessions", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "cannot remove container %s as it has active exec sessions", c.ID())
} }
return nil return nil

5
libpod/container_internal_linux.go
View File

@ -20,6 +20,7 @@ import (
cnitypes "github.com/containernetworking/cni/pkg/types/current" cnitypes "github.com/containernetworking/cni/pkg/types/current"
"github.com/containernetworking/plugins/pkg/ns" "github.com/containernetworking/plugins/pkg/ns"
"github.com/containers/buildah/pkg/secrets" "github.com/containers/buildah/pkg/secrets"
"github.com/containers/libpod/libpod/define"
crioAnnotations "github.com/containers/libpod/pkg/annotations" crioAnnotations "github.com/containers/libpod/pkg/annotations"
"github.com/containers/libpod/pkg/apparmor" "github.com/containers/libpod/pkg/apparmor"
"github.com/containers/libpod/pkg/criu" "github.com/containers/libpod/pkg/criu"
@ -568,7 +569,7 @@ func (c *Container) checkpoint(ctx context.Context, options ContainerCheckpointO
} }
if c.state.State != ContainerStateRunning { if c.state.State != ContainerStateRunning {
return errors.Wrapf(ErrCtrStateInvalid, "%q is not running, cannot checkpoint", c.state.State) return errors.Wrapf(define.ErrCtrStateInvalid, "%q is not running, cannot checkpoint", c.state.State)
} }
if err := c.checkpointRestoreLabelLog("dump.log"); err != nil { if err := c.checkpointRestoreLabelLog("dump.log"); err != nil {
@ -659,7 +660,7 @@ func (c *Container) restore(ctx context.Context, options ContainerCheckpointOpti
} }
if (c.state.State != ContainerStateConfigured) && (c.state.State != ContainerStateExited) { if (c.state.State != ContainerStateConfigured) && (c.state.State != ContainerStateExited) {
return errors.Wrapf(ErrCtrStateInvalid, "container %s is running or paused, cannot restore", c.ID()) return errors.Wrapf(define.ErrCtrStateInvalid, "container %s is running or paused, cannot restore", c.ID())
} }
if options.TargetFile != "" { if options.TargetFile != "" {

15
libpod/container_internal_unsupported.go
View File

@ -5,35 +5,36 @@ package libpod
import ( import (
"context" "context"
"github.com/containers/libpod/libpod/define"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
) )
func (c *Container) mountSHM(shmOptions string) error { func (c *Container) mountSHM(shmOptions string) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) unmountSHM(mount string) error { func (c *Container) unmountSHM(mount string) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) prepare() (err error) { func (c *Container) prepare() (err error) {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) cleanupNetwork() error { func (c *Container) cleanupNetwork() error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) generateSpec(ctx context.Context) (*spec.Spec, error) { func (c *Container) generateSpec(ctx context.Context) (*spec.Spec, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }
func (c *Container) checkpoint(ctx context.Context, options ContainerCheckpointOptions) error { func (c *Container) checkpoint(ctx context.Context, options ContainerCheckpointOptions) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) restore(ctx context.Context, options ContainerCheckpointOptions) error { func (c *Container) restore(ctx context.Context, options ContainerCheckpointOptions) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) copyOwnerAndPerms(source, dest string) error { func (c *Container) copyOwnerAndPerms(source, dest string) error {

3
libpod/container_log_unsupported.go
View File

@ -3,9 +3,10 @@
package libpod package libpod
import ( import (
"github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
func (c *Container) readFromJournal(options *LogOptions, logChannel chan *LogLine) error { func (c *Container) readFromJournal(options *LogOptions, logChannel chan *LogLine) error {
return errors.Wrapf(ErrOSNotSupported, "Journald logging only enabled with systemd on linux") return errors.Wrapf(define.ErrOSNotSupported, "Journald logging only enabled with systemd on linux")
} }

6
libpod/container_top_unsupported.go
View File

@ -2,6 +2,8 @@
package libpod package libpod
import "github.com/containers/libpod/libpod/define"
// GetContainerPidInformation returns process-related data of all processes in // GetContainerPidInformation returns process-related data of all processes in
// the container. The output data can be controlled via the `descriptors` // the container. The output data can be controlled via the `descriptors`
// argument which expects format descriptors and supports all AIXformat // argument which expects format descriptors and supports all AIXformat
@ -11,11 +13,11 @@ package libpod
// //
// For more details, please refer to github.com/containers/psgo. // For more details, please refer to github.com/containers/psgo.
func (c *Container) GetContainerPidInformation(descriptors []string) ([]string, error) { func (c *Container) GetContainerPidInformation(descriptors []string) ([]string, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }
// GetContainerPidInformationDescriptors returns a string slice of all supported // GetContainerPidInformationDescriptors returns a string slice of all supported
// format descriptors of GetContainerPidInformation. // format descriptors of GetContainerPidInformation.
func GetContainerPidInformationDescriptors() ([]string, error) { func GetContainerPidInformationDescriptors() ([]string, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }

10
libpod/define/config.go Normal file
View File

@ -0,0 +1,10 @@
package define
var (
// DefaultInitPath is the default path to the container-init binary
DefaultInitPath = "/usr/libexec/podman/catatonit"
)
// CtrRemoveTimeout is the default number of seconds to wait after stopping a container
// before sending the kill signal
const CtrRemoveTimeout = 10

2
libpod/errors.go → libpod/define/errors.go
View File

@ -1,4 +1,4 @@
package libpod package define
import ( import (
"errors" "errors"

8
libpod/healthcheck_unsupported.go
View File

@ -2,18 +2,20 @@
package libpod package libpod
import "github.com/containers/libpod/libpod/define"
// createTimer systemd timers for healthchecks of a container // createTimer systemd timers for healthchecks of a container
func (c *Container) createTimer() error { func (c *Container) createTimer() error {
return ErrNotImplemented return define.ErrNotImplemented
} }
// startTimer starts a systemd timer for the healthchecks // startTimer starts a systemd timer for the healthchecks
func (c *Container) startTimer() error { func (c *Container) startTimer() error {
return ErrNotImplemented return define.ErrNotImplemented
} }
// removeTimer removes the systemd timer and unit files // removeTimer removes the systemd timer and unit files
// for the container // for the container
func (c *Container) removeTimer() error { func (c *Container) removeTimer() error {
return ErrNotImplemented return define.ErrNotImplemented
} }

165
libpod/in_memory_state.go
View File

@ -3,6 +3,7 @@ package libpod
import ( import (
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/registrar" "github.com/containers/libpod/pkg/registrar"
"github.com/containers/storage/pkg/truncindex" "github.com/containers/storage/pkg/truncindex"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -99,12 +100,12 @@ func (s *InMemoryState) SetNamespace(ns string) error {
// Container retrieves a container from its full ID // Container retrieves a container from its full ID
func (s *InMemoryState) Container(id string) (*Container, error) { func (s *InMemoryState) Container(id string) (*Container, error) {
if id == "" { if id == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
ctr, ok := s.containers[id] ctr, ok := s.containers[id]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found", id) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found", id)
} }
if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil { if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@ -122,7 +123,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
) )
if idOrName == "" { if idOrName == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if s.namespace != "" { if s.namespace != "" {
@ -130,7 +131,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
if !ok { if !ok {
// We have no containers in the namespace // We have no containers in the namespace
// Return false // Return false
return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
} }
nameIndex = nsIndex.nameIndex nameIndex = nsIndex.nameIndex
idIndex = nsIndex.idIndex idIndex = nsIndex.idIndex
@ -146,7 +147,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
fullID, err = idIndex.Get(idOrName) fullID, err = idIndex.Get(idOrName)
if err != nil { if err != nil {
if err == truncindex.ErrNotExist { if err == truncindex.ErrNotExist {
return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
} }
return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName) return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName)
} }
@ -158,7 +159,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
ctr, ok := s.containers[fullID] ctr, ok := s.containers[fullID]
if !ok { if !ok {
// It's a pod, not a container // It's a pod, not a container
return nil, errors.Wrapf(ErrNoSuchCtr, "name or ID %s is a pod, not a container", idOrName) return nil, errors.Wrapf(define.ErrNoSuchCtr, "name or ID %s is a pod, not a container", idOrName)
} }
return ctr, nil return ctr, nil
@ -167,7 +168,7 @@ func (s *InMemoryState) LookupContainer(idOrName string) (*Container, error) {
// HasContainer checks if a container with the given ID is present in the state // HasContainer checks if a container with the given ID is present in the state
func (s *InMemoryState) HasContainer(id string) (bool, error) { func (s *InMemoryState) HasContainer(id string) (bool, error) {
if id == "" { if id == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
ctr, ok := s.containers[id] ctr, ok := s.containers[id]
@ -182,15 +183,15 @@ func (s *InMemoryState) HasContainer(id string) (bool, error) {
// Containers in a pod cannot be added to the state // Containers in a pod cannot be added to the state
func (s *InMemoryState) AddContainer(ctr *Container) error { func (s *InMemoryState) AddContainer(ctr *Container) error {
if !ctr.valid { if !ctr.valid {
return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
} }
if _, ok := s.containers[ctr.ID()]; ok { if _, ok := s.containers[ctr.ID()]; ok {
return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in state", ctr.ID()) return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
} }
if ctr.config.Pod != "" { if ctr.config.Pod != "" {
return errors.Wrapf(ErrInvalidArg, "cannot add a container that is in a pod with AddContainer, use AddContainerToPod") return errors.Wrapf(define.ErrInvalidArg, "cannot add a container that is in a pod with AddContainer, use AddContainerToPod")
} }
if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil { if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@ -204,12 +205,12 @@ func (s *InMemoryState) AddContainer(ctr *Container) error {
for _, depID := range depCtrs { for _, depID := range depCtrs {
depCtr, ok := s.containers[depID] depCtr, ok := s.containers[depID]
if !ok { if !ok {
return errors.Wrapf(ErrNoSuchCtr, "cannot depend on nonexistent container %s", depID) return errors.Wrapf(define.ErrNoSuchCtr, "cannot depend on nonexistent container %s", depID)
} else if depCtr.config.Pod != "" { } else if depCtr.config.Pod != "" {
return errors.Wrapf(ErrInvalidArg, "cannot depend on container in a pod if not part of same pod") return errors.Wrapf(define.ErrInvalidArg, "cannot depend on container in a pod if not part of same pod")
} }
if depCtr.config.Namespace != ctr.config.Namespace { if depCtr.config.Namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depID, depCtr.config.Namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depID, depCtr.config.Namespace)
} }
} }
@ -270,12 +271,12 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
deps, ok := s.ctrDepends[ctr.ID()] deps, ok := s.ctrDepends[ctr.ID()]
if ok && len(deps) != 0 { if ok && len(deps) != 0 {
depsStr := strings.Join(deps, ", ") depsStr := strings.Join(deps, ", ")
return errors.Wrapf(ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr) return errors.Wrapf(define.ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
} }
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
} }
if err := s.idIndex.Delete(ctr.ID()); err != nil { if err := s.idIndex.Delete(ctr.ID()); err != nil {
@ -289,7 +290,7 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
if ctr.config.Namespace != "" { if ctr.config.Namespace != "" {
nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace] nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace]
if !ok { if !ok {
return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace) return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
} }
if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil { if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil {
return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID()) return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID())
@ -317,13 +318,13 @@ func (s *InMemoryState) RemoveContainer(ctr *Container) error {
func (s *InMemoryState) UpdateContainer(ctr *Container) error { func (s *InMemoryState) UpdateContainer(ctr *Container) error {
// If the container is invalid, return error // If the container is invalid, return error
if !ctr.valid { if !ctr.valid {
return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
} }
// If the container does not exist, return error // If the container does not exist, return error
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
} }
return s.checkNSMatch(ctr.ID(), ctr.Namespace()) return s.checkNSMatch(ctr.ID(), ctr.Namespace())
@ -336,13 +337,13 @@ func (s *InMemoryState) UpdateContainer(ctr *Container) error {
func (s *InMemoryState) SaveContainer(ctr *Container) error { func (s *InMemoryState) SaveContainer(ctr *Container) error {
// If the container is invalid, return error // If the container is invalid, return error
if !ctr.valid { if !ctr.valid {
return errors.Wrapf(ErrCtrRemoved, "container with ID %s is not valid", ctr.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container with ID %s is not valid", ctr.ID())
} }
// If the container does not exist, return error // If the container does not exist, return error
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
} }
return s.checkNSMatch(ctr.ID(), ctr.Namespace()) return s.checkNSMatch(ctr.ID(), ctr.Namespace())
@ -351,13 +352,13 @@ func (s *InMemoryState) SaveContainer(ctr *Container) error {
// ContainerInUse checks if the given container is being used by other containers // ContainerInUse checks if the given container is being used by other containers
func (s *InMemoryState) ContainerInUse(ctr *Container) ([]string, error) { func (s *InMemoryState) ContainerInUse(ctr *Container) ([]string, error) {
if !ctr.valid { if !ctr.valid {
return nil, ErrCtrRemoved return nil, define.ErrCtrRemoved
} }
// If the container does not exist, return error // If the container does not exist, return error
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
ctr.valid = false ctr.valid = false
return nil, errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID()) return nil, errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
} }
if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil { if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@ -389,14 +390,14 @@ func (s *InMemoryState) AllContainers() ([]*Container, error) {
// Please read the full comment on it in state.go before using it. // Please read the full comment on it in state.go before using it.
func (s *InMemoryState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error { func (s *InMemoryState) RewriteContainerConfig(ctr *Container, newCfg *ContainerConfig) error {
if !ctr.valid { if !ctr.valid {
return ErrCtrRemoved return define.ErrCtrRemoved
} }
// If the container does not exist, return error // If the container does not exist, return error
stateCtr, ok := s.containers[ctr.ID()] stateCtr, ok := s.containers[ctr.ID()]
if !ok { if !ok {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in state", ctr.ID())
} }
stateCtr.config = newCfg stateCtr.config = newCfg
@ -409,14 +410,14 @@ func (s *InMemoryState) RewriteContainerConfig(ctr *Container, newCfg *Container
// Please read the full comment on it in state.go before using it. // Please read the full comment on it in state.go before using it.
func (s *InMemoryState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error { func (s *InMemoryState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
// If the pod does not exist, return error // If the pod does not exist, return error
statePod, ok := s.pods[pod.ID()] statePod, ok := s.pods[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "pod with ID %s not found in state", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "pod with ID %s not found in state", pod.ID())
} }
statePod.config = newCfg statePod.config = newCfg
@ -427,12 +428,12 @@ func (s *InMemoryState) RewritePodConfig(pod *Pod, newCfg *PodConfig) error {
// Volume retrieves a volume from its full name // Volume retrieves a volume from its full name
func (s *InMemoryState) Volume(name string) (*Volume, error) { func (s *InMemoryState) Volume(name string) (*Volume, error) {
if name == "" { if name == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
vol, ok := s.volumes[name] vol, ok := s.volumes[name]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchCtr, "no volume with name %s found", name) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no volume with name %s found", name)
} }
return vol, nil return vol, nil
@ -441,7 +442,7 @@ func (s *InMemoryState) Volume(name string) (*Volume, error) {
// HasVolume checks if a volume with the given name is present in the state // HasVolume checks if a volume with the given name is present in the state
func (s *InMemoryState) HasVolume(name string) (bool, error) { func (s *InMemoryState) HasVolume(name string) (bool, error) {
if name == "" { if name == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
_, ok := s.volumes[name] _, ok := s.volumes[name]
@ -455,11 +456,11 @@ func (s *InMemoryState) HasVolume(name string) (bool, error) {
// AddVolume adds a volume to the state // AddVolume adds a volume to the state
func (s *InMemoryState) AddVolume(volume *Volume) error { func (s *InMemoryState) AddVolume(volume *Volume) error {
if !volume.valid { if !volume.valid {
return errors.Wrapf(ErrVolumeRemoved, "volume with name %s is not valid", volume.Name()) return errors.Wrapf(define.ErrVolumeRemoved, "volume with name %s is not valid", volume.Name())
} }
if _, ok := s.volumes[volume.Name()]; ok { if _, ok := s.volumes[volume.Name()]; ok {
return errors.Wrapf(ErrVolumeExists, "volume with name %s already exists in state", volume.Name()) return errors.Wrapf(define.ErrVolumeExists, "volume with name %s already exists in state", volume.Name())
} }
s.volumes[volume.Name()] = volume s.volumes[volume.Name()] = volume
@ -473,12 +474,12 @@ func (s *InMemoryState) RemoveVolume(volume *Volume) error {
deps, ok := s.volumeDepends[volume.Name()] deps, ok := s.volumeDepends[volume.Name()]
if ok && len(deps) != 0 { if ok && len(deps) != 0 {
depsStr := strings.Join(deps, ", ") depsStr := strings.Join(deps, ", ")
return errors.Wrapf(ErrVolumeExists, "the following containers depend on volume %s: %s", volume.Name(), depsStr) return errors.Wrapf(define.ErrVolumeExists, "the following containers depend on volume %s: %s", volume.Name(), depsStr)
} }
if _, ok := s.volumes[volume.Name()]; !ok { if _, ok := s.volumes[volume.Name()]; !ok {
volume.valid = false volume.valid = false
return errors.Wrapf(ErrVolumeRemoved, "no volume exists in state with name %s", volume.Name()) return errors.Wrapf(define.ErrVolumeRemoved, "no volume exists in state with name %s", volume.Name())
} }
delete(s.volumes, volume.Name()) delete(s.volumes, volume.Name())
@ -489,13 +490,13 @@ func (s *InMemoryState) RemoveVolume(volume *Volume) error {
// VolumeInUse checks if the given volume is being used by at least one container // VolumeInUse checks if the given volume is being used by at least one container
func (s *InMemoryState) VolumeInUse(volume *Volume) ([]string, error) { func (s *InMemoryState) VolumeInUse(volume *Volume) ([]string, error) {
if !volume.valid { if !volume.valid {
return nil, ErrVolumeRemoved return nil, define.ErrVolumeRemoved
} }
// If the volume does not exist, return error // If the volume does not exist, return error
if _, ok := s.volumes[volume.Name()]; !ok { if _, ok := s.volumes[volume.Name()]; !ok {
volume.valid = false volume.valid = false
return nil, errors.Wrapf(ErrNoSuchVolume, "volume with name %s not found in state", volume.Name()) return nil, errors.Wrapf(define.ErrNoSuchVolume, "volume with name %s not found in state", volume.Name())
} }
arr, ok := s.volumeDepends[volume.Name()] arr, ok := s.volumeDepends[volume.Name()]
@ -519,12 +520,12 @@ func (s *InMemoryState) AllVolumes() ([]*Volume, error) {
// Pod retrieves a pod from the state from its full ID // Pod retrieves a pod from the state from its full ID
func (s *InMemoryState) Pod(id string) (*Pod, error) { func (s *InMemoryState) Pod(id string) (*Pod, error) {
if id == "" { if id == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
pod, ok := s.pods[id] pod, ok := s.pods[id]
if !ok { if !ok {
return nil, errors.Wrapf(ErrNoSuchPod, "no pod with id %s found", id) return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with id %s found", id)
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -543,7 +544,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
) )
if idOrName == "" { if idOrName == "" {
return nil, ErrEmptyID return nil, define.ErrEmptyID
} }
if s.namespace != "" { if s.namespace != "" {
@ -551,7 +552,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
if !ok { if !ok {
// We have no containers in the namespace // We have no containers in the namespace
// Return false // Return false
return nil, errors.Wrapf(ErrNoSuchCtr, "no container found with name or ID %s", idOrName) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container found with name or ID %s", idOrName)
} }
nameIndex = nsIndex.nameIndex nameIndex = nsIndex.nameIndex
idIndex = nsIndex.idIndex idIndex = nsIndex.idIndex
@ -567,7 +568,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
fullID, err = idIndex.Get(idOrName) fullID, err = idIndex.Get(idOrName)
if err != nil { if err != nil {
if err == truncindex.ErrNotExist { if err == truncindex.ErrNotExist {
return nil, errors.Wrapf(ErrNoSuchPod, "no pod found with name or ID %s", idOrName) return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod found with name or ID %s", idOrName)
} }
return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName) return nil, errors.Wrapf(err, "error performing truncindex lookup for ID %s", idOrName)
} }
@ -579,7 +580,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
pod, ok := s.pods[fullID] pod, ok := s.pods[fullID]
if !ok { if !ok {
// It's a container not a pod // It's a container not a pod
return nil, errors.Wrapf(ErrNoSuchPod, "id or name %s is a container not a pod", idOrName) return nil, errors.Wrapf(define.ErrNoSuchPod, "id or name %s is a container not a pod", idOrName)
} }
return pod, nil return pod, nil
@ -588,7 +589,7 @@ func (s *InMemoryState) LookupPod(idOrName string) (*Pod, error) {
// HasPod checks if a pod with the given ID is present in the state // HasPod checks if a pod with the given ID is present in the state
func (s *InMemoryState) HasPod(id string) (bool, error) { func (s *InMemoryState) HasPod(id string) (bool, error) {
if id == "" { if id == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
pod, ok := s.pods[id] pod, ok := s.pods[id]
@ -602,11 +603,11 @@ func (s *InMemoryState) HasPod(id string) (bool, error) {
// PodHasContainer checks if the given pod has a container with the given ID // PodHasContainer checks if the given pod has a container with the given ID
func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) { func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
if !pod.valid { if !pod.valid {
return false, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID()) return false, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
} }
if ctrID == "" { if ctrID == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -616,7 +617,7 @@ func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return false, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID()) return false, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
} }
_, ok = podCtrs[ctrID] _, ok = podCtrs[ctrID]
@ -626,7 +627,7 @@ func (s *InMemoryState) PodHasContainer(pod *Pod, ctrID string) (bool, error) {
// PodContainersByID returns the IDs of all containers in the given pod // PodContainersByID returns the IDs of all containers in the given pod
func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) { func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
if !pod.valid { if !pod.valid {
return nil, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID()) return nil, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -636,7 +637,7 @@ func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return nil, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID()) return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
} }
length := len(podCtrs) length := len(podCtrs)
@ -655,7 +656,7 @@ func (s *InMemoryState) PodContainersByID(pod *Pod) ([]string, error) {
// PodContainers retrieves the containers from a pod // PodContainers retrieves the containers from a pod
func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) { func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
if !pod.valid { if !pod.valid {
return nil, errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID()) return nil, errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -665,7 +666,7 @@ func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return nil, errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in state", pod.ID()) return nil, errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in state", pod.ID())
} }
length := len(podCtrs) length := len(podCtrs)
@ -684,7 +685,7 @@ func (s *InMemoryState) PodContainers(pod *Pod) ([]*Container, error) {
// AddPod adds a given pod to the state // AddPod adds a given pod to the state
func (s *InMemoryState) AddPod(pod *Pod) error { func (s *InMemoryState) AddPod(pod *Pod) error {
if !pod.valid { if !pod.valid {
return errors.Wrapf(ErrPodRemoved, "pod %s is not valid and cannot be added", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid and cannot be added", pod.ID())
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -692,11 +693,11 @@ func (s *InMemoryState) AddPod(pod *Pod) error {
} }
if _, ok := s.pods[pod.ID()]; ok { if _, ok := s.pods[pod.ID()]; ok {
return errors.Wrapf(ErrPodExists, "pod with ID %s already exists in state", pod.ID()) return errors.Wrapf(define.ErrPodExists, "pod with ID %s already exists in state", pod.ID())
} }
if _, ok := s.podContainers[pod.ID()]; ok { if _, ok := s.podContainers[pod.ID()]; ok {
return errors.Wrapf(ErrPodExists, "pod with ID %s already exists in state", pod.ID()) return errors.Wrapf(define.ErrPodExists, "pod with ID %s already exists in state", pod.ID())
} }
if err := s.nameIndex.Reserve(pod.Name(), pod.ID()); err != nil { if err := s.nameIndex.Reserve(pod.Name(), pod.ID()); err != nil {
@ -746,15 +747,15 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
if _, ok := s.pods[pod.ID()]; !ok { if _, ok := s.pods[pod.ID()]; !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
} }
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
} }
if len(podCtrs) != 0 { if len(podCtrs) != 0 {
return errors.Wrapf(ErrCtrExists, "pod %s is not empty and cannot be removed", pod.ID()) return errors.Wrapf(define.ErrCtrExists, "pod %s is not empty and cannot be removed", pod.ID())
} }
if err := s.idIndex.Delete(pod.ID()); err != nil { if err := s.idIndex.Delete(pod.ID()); err != nil {
@ -767,7 +768,7 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
if pod.config.Namespace != "" { if pod.config.Namespace != "" {
nsIndex, ok := s.namespaceIndexes[pod.config.Namespace] nsIndex, ok := s.namespaceIndexes[pod.config.Namespace]
if !ok { if !ok {
return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", pod.config.Namespace) return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", pod.config.Namespace)
} }
if err := nsIndex.idIndex.Delete(pod.ID()); err != nil { if err := nsIndex.idIndex.Delete(pod.ID()); err != nil {
return errors.Wrapf(err, "error removing container %s from namespace ID index", pod.ID()) return errors.Wrapf(err, "error removing container %s from namespace ID index", pod.ID())
@ -784,7 +785,7 @@ func (s *InMemoryState) RemovePod(pod *Pod) error {
// Will only remove containers if no dependencies outside of the pod are present // Will only remove containers if no dependencies outside of the pod are present
func (s *InMemoryState) RemovePodContainers(pod *Pod) error { func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
if !pod.valid { if !pod.valid {
return errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -795,7 +796,7 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
} }
// Go through container dependencies. Check to see if any are outside the pod. // Go through container dependencies. Check to see if any are outside the pod.
@ -804,7 +805,7 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
if ok { if ok {
for _, dep := range ctrDeps { for _, dep := range ctrDeps {
if _, ok := podCtrs[dep]; !ok { if _, ok := podCtrs[dep]; !ok {
return errors.Wrapf(ErrCtrExists, "container %s has dependency %s outside of pod %s", ctr, dep, pod.ID()) return errors.Wrapf(define.ErrCtrExists, "container %s has dependency %s outside of pod %s", ctr, dep, pod.ID())
} }
} }
} }
@ -830,18 +831,18 @@ func (s *InMemoryState) RemovePodContainers(pod *Pod) error {
// state // state
func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error { func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
if !pod.valid { if !pod.valid {
return errors.Wrapf(ErrPodRemoved, "pod %s is not valid", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid", pod.ID())
} }
if !ctr.valid { if !ctr.valid {
return errors.Wrapf(ErrCtrRemoved, "container %s is not valid", ctr.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid", ctr.ID())
} }
if ctr.config.Pod != pod.ID() { if ctr.config.Pod != pod.ID() {
return errors.Wrapf(ErrInvalidArg, "container %s is not in pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrInvalidArg, "container %s is not in pod %s", ctr.ID(), pod.ID())
} }
if ctr.config.Namespace != pod.config.Namespace { if ctr.config.Namespace != pod.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s", return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace) ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace)
} }
@ -853,12 +854,12 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrPodRemoved, "pod %s not found in state", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s not found in state", pod.ID())
} }
// Is the container already in the pod? // Is the container already in the pod?
if _, ok = podCtrs[ctr.ID()]; ok { if _, ok = podCtrs[ctr.ID()]; ok {
return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in pod %s", ctr.ID(), pod.ID())
} }
// There are potential race conditions with this // There are potential race conditions with this
@ -867,20 +868,20 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
depCtrs := ctr.Dependencies() depCtrs := ctr.Dependencies()
for _, depCtr := range depCtrs { for _, depCtr := range depCtrs {
if _, ok = s.containers[depCtr]; !ok { if _, ok = s.containers[depCtr]; !ok {
return errors.Wrapf(ErrNoSuchCtr, "cannot depend on nonexistent container %s", depCtr) return errors.Wrapf(define.ErrNoSuchCtr, "cannot depend on nonexistent container %s", depCtr)
} }
depCtrStruct, ok := podCtrs[depCtr] depCtrStruct, ok := podCtrs[depCtr]
if !ok { if !ok {
return errors.Wrapf(ErrInvalidArg, "cannot depend on container %s as it is not in pod %s", depCtr, pod.ID()) return errors.Wrapf(define.ErrInvalidArg, "cannot depend on container %s as it is not in pod %s", depCtr, pod.ID())
} }
if depCtrStruct.config.Namespace != ctr.config.Namespace { if depCtrStruct.config.Namespace != ctr.config.Namespace {
return errors.Wrapf(ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depCtr, depCtrStruct.config.Namespace) return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and cannot depend on container %s in namespace %s", ctr.ID(), ctr.config.Namespace, depCtr, depCtrStruct.config.Namespace)
} }
} }
// Add container to state // Add container to state
if _, ok = s.containers[ctr.ID()]; ok { if _, ok = s.containers[ctr.ID()]; ok {
return errors.Wrapf(ErrCtrExists, "container with ID %s already exists in state", ctr.ID()) return errors.Wrapf(define.ErrCtrExists, "container with ID %s already exists in state", ctr.ID())
} }
if err := s.nameIndex.Reserve(ctr.Name(), ctr.ID()); err != nil { if err := s.nameIndex.Reserve(ctr.Name(), ctr.ID()); err != nil {
@ -928,10 +929,10 @@ func (s *InMemoryState) AddContainerToPod(pod *Pod, ctr *Container) error {
// The container is also removed from the state // The container is also removed from the state
func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error { func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
if !pod.valid { if !pod.valid {
return errors.Wrapf(ErrPodRemoved, "pod %s is not valid and containers cannot be removed", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s is not valid and containers cannot be removed", pod.ID())
} }
if !ctr.valid { if !ctr.valid {
return errors.Wrapf(ErrCtrRemoved, "container %s is not valid and cannot be removed from the pod", ctr.ID()) return errors.Wrapf(define.ErrCtrRemoved, "container %s is not valid and cannot be removed from the pod", ctr.ID())
} }
if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil { if err := s.checkNSMatch(ctr.ID(), ctr.Namespace()); err != nil {
@ -942,30 +943,30 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
deps, ok := s.ctrDepends[ctr.ID()] deps, ok := s.ctrDepends[ctr.ID()]
if ok && len(deps) != 0 { if ok && len(deps) != 0 {
depsStr := strings.Join(deps, ", ") depsStr := strings.Join(deps, ", ")
return errors.Wrapf(ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr) return errors.Wrapf(define.ErrCtrExists, "the following containers depend on container %s: %s", ctr.ID(), depsStr)
} }
// Retrieve pod containers // Retrieve pod containers
podCtrs, ok := s.podContainers[pod.ID()] podCtrs, ok := s.podContainers[pod.ID()]
if !ok { if !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrPodRemoved, "pod %s has been removed", pod.ID()) return errors.Wrapf(define.ErrPodRemoved, "pod %s has been removed", pod.ID())
} }
// Does the container exist? // Does the container exist?
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
ctr.valid = false ctr.valid = false
return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in state", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container %s does not exist in state", ctr.ID())
} }
// Is the container in the pod? // Is the container in the pod?
if _, ok := podCtrs[ctr.ID()]; !ok { if _, ok := podCtrs[ctr.ID()]; !ok {
return errors.Wrapf(ErrNoSuchCtr, "container with ID %s not found in pod %s", ctr.ID(), pod.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "container with ID %s not found in pod %s", ctr.ID(), pod.ID())
} }
// Remove container from state // Remove container from state
if _, ok := s.containers[ctr.ID()]; !ok { if _, ok := s.containers[ctr.ID()]; !ok {
return errors.Wrapf(ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID()) return errors.Wrapf(define.ErrNoSuchCtr, "no container exists in state with ID %s", ctr.ID())
} }
if err := s.idIndex.Delete(ctr.ID()); err != nil { if err := s.idIndex.Delete(ctr.ID()); err != nil {
@ -980,7 +981,7 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
if ctr.config.Namespace != "" { if ctr.config.Namespace != "" {
nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace] nsIndex, ok := s.namespaceIndexes[ctr.config.Namespace]
if !ok { if !ok {
return errors.Wrapf(ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace) return errors.Wrapf(define.ErrInternal, "error retrieving index for namespace %q", ctr.config.Namespace)
} }
if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil { if err := nsIndex.idIndex.Delete(ctr.ID()); err != nil {
return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID()) return errors.Wrapf(err, "error removing container %s from namespace ID index", ctr.ID())
@ -1001,7 +1002,7 @@ func (s *InMemoryState) RemoveContainerFromPod(pod *Pod, ctr *Container) error {
// This is a no-op as there is no backing store // This is a no-op as there is no backing store
func (s *InMemoryState) UpdatePod(pod *Pod) error { func (s *InMemoryState) UpdatePod(pod *Pod) error {
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -1010,7 +1011,7 @@ func (s *InMemoryState) UpdatePod(pod *Pod) error {
if _, ok := s.pods[pod.ID()]; !ok { if _, ok := s.pods[pod.ID()]; !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
} }
return nil return nil
@ -1020,7 +1021,7 @@ func (s *InMemoryState) UpdatePod(pod *Pod) error {
// This is a no-op at there is no backing store // This is a no-op at there is no backing store
func (s *InMemoryState) SavePod(pod *Pod) error { func (s *InMemoryState) SavePod(pod *Pod) error {
if !pod.valid { if !pod.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil { if err := s.checkNSMatch(pod.ID(), pod.Namespace()); err != nil {
@ -1029,7 +1030,7 @@ func (s *InMemoryState) SavePod(pod *Pod) error {
if _, ok := s.pods[pod.ID()]; !ok { if _, ok := s.pods[pod.ID()]; !ok {
pod.valid = false pod.valid = false
return errors.Wrapf(ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID()) return errors.Wrapf(define.ErrNoSuchPod, "no pod exists in state with ID %s", pod.ID())
} }
return nil return nil
@ -1133,7 +1134,7 @@ func (s *InMemoryState) removeCtrFromVolDependsMap(depCtrID, volName string) {
// namespaces. // namespaces.
func (s *InMemoryState) checkNSMatch(id, ns string) error { func (s *InMemoryState) checkNSMatch(id, ns string) error {
if s.namespace != "" && s.namespace != ns { if s.namespace != "" && s.namespace != ns {
return errors.Wrapf(ErrNSMismatch, "cannot access %s as it is in namespace %q and we are in namespace %q", return errors.Wrapf(define.ErrNSMismatch, "cannot access %s as it is in namespace %q and we are in namespace %q",
id, ns, s.namespace) id, ns, s.namespace)
} }
return nil return nil

3
libpod/kube.go
View File

@ -7,6 +7,7 @@ import (
"strings" "strings"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/lookup" "github.com/containers/libpod/pkg/lookup"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
@ -209,7 +210,7 @@ func containerToV1Container(c *Container) (v1.Container, error) {
return kubeContainer, err return kubeContainer, err
} }
kubeContainer.VolumeDevices = devices kubeContainer.VolumeDevices = devices
return kubeContainer, errors.Wrapf(ErrNotImplemented, "linux devices") return kubeContainer, errors.Wrapf(define.ErrNotImplemented, "linux devices")
} }
if len(c.config.UserVolumes) > 0 { if len(c.config.UserVolumes) > 0 {

10
libpod/networking_unsupported.go
View File

@ -2,20 +2,22 @@
package libpod package libpod
import "github.com/containers/libpod/libpod/define"
func (r *Runtime) setupRootlessNetNS(ctr *Container) (err error) { func (r *Runtime) setupRootlessNetNS(ctr *Container) (err error) {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (r *Runtime) setupNetNS(ctr *Container) (err error) { func (r *Runtime) setupNetNS(ctr *Container) (err error) {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (r *Runtime) teardownNetNS(ctr *Container) error { func (r *Runtime) teardownNetNS(ctr *Container) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (r *Runtime) createNetNS(ctr *Container) (err error) { func (r *Runtime) createNetNS(ctr *Container) (err error) {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (c *Container) getContainerNetworkInfo(data *InspectContainerData) *InspectContainerData { func (c *Container) getContainerNetworkInfo(data *InspectContainerData) *InspectContainerData {

13
libpod/oci.go
View File

@ -11,6 +11,7 @@ import (
"strings" "strings"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
@ -79,7 +80,7 @@ type ociError struct {
// The first path that points to a valid executable will be used. // The first path that points to a valid executable will be used.
func newOCIRuntime(name string, paths []string, conmonPath string, runtimeCfg *RuntimeConfig, supportsJSON bool) (*OCIRuntime, error) { func newOCIRuntime(name string, paths []string, conmonPath string, runtimeCfg *RuntimeConfig, supportsJSON bool) (*OCIRuntime, error) {
if name == "" { if name == "" {
return nil, errors.Wrapf(ErrInvalidArg, "the OCI runtime must be provided a non-empty name") return nil, errors.Wrapf(define.ErrInvalidArg, "the OCI runtime must be provided a non-empty name")
} }
runtime := new(OCIRuntime) runtime := new(OCIRuntime)
@ -114,14 +115,14 @@ func newOCIRuntime(name string, paths []string, conmonPath string, runtimeCfg *R
break break
} }
if !foundPath { if !foundPath {
return nil, errors.Wrapf(ErrInvalidArg, "no valid executable found for OCI runtime %s", name) return nil, errors.Wrapf(define.ErrInvalidArg, "no valid executable found for OCI runtime %s", name)
} }
runtime.exitsDir = filepath.Join(runtime.tmpDir, "exits") runtime.exitsDir = filepath.Join(runtime.tmpDir, "exits")
runtime.socketsDir = filepath.Join(runtime.tmpDir, "socket") runtime.socketsDir = filepath.Join(runtime.tmpDir, "socket")
if runtime.cgroupManager != CgroupfsCgroupsManager && runtime.cgroupManager != SystemdCgroupsManager { if runtime.cgroupManager != CgroupfsCgroupsManager && runtime.cgroupManager != SystemdCgroupsManager {
return nil, errors.Wrapf(ErrInvalidArg, "invalid cgroup manager specified: %s", runtime.cgroupManager) return nil, errors.Wrapf(define.ErrInvalidArg, "invalid cgroup manager specified: %s", runtime.cgroupManager)
} }
// Create the exit files and attach sockets directories // Create the exit files and attach sockets directories
@ -290,7 +291,7 @@ func (r *OCIRuntime) updateContainerStatus(ctr *Container, useRuntime bool) erro
case "stopped": case "stopped":
ctr.state.State = ContainerStateStopped ctr.state.State = ContainerStateStopped
default: default:
return errors.Wrapf(ErrInternal, "unrecognized status returned by runtime for container %s: %s", return errors.Wrapf(define.ErrInternal, "unrecognized status returned by runtime for container %s: %s",
ctr.ID(), state.Status) ctr.ID(), state.Status)
} }
@ -390,11 +391,11 @@ func (r *OCIRuntime) unpauseContainer(ctr *Container) error {
// TODO: add --pid-file and use that to generate exec session tracking // TODO: add --pid-file and use that to generate exec session tracking
func (r *OCIRuntime) execContainer(c *Container, cmd, capAdd, env []string, tty bool, cwd, user, sessionID string, streams *AttachStreams, preserveFDs int) (*exec.Cmd, error) { func (r *OCIRuntime) execContainer(c *Container, cmd, capAdd, env []string, tty bool, cwd, user, sessionID string, streams *AttachStreams, preserveFDs int) (*exec.Cmd, error) {
if len(cmd) == 0 { if len(cmd) == 0 {
return nil, errors.Wrapf(ErrInvalidArg, "must provide a command to execute") return nil, errors.Wrapf(define.ErrInvalidArg, "must provide a command to execute")
} }
if sessionID == "" { if sessionID == "" {
return nil, errors.Wrapf(ErrEmptyID, "must provide a session ID for exec") return nil, errors.Wrapf(define.ErrEmptyID, "must provide a session ID for exec")
} }
runtimeDir, err := util.GetRootlessRuntimeDir() runtimeDir, err := util.GetRootlessRuntimeDir()

9
libpod/oci_linux.go
View File

@ -16,6 +16,7 @@ import (
"time" "time"
"github.com/containerd/cgroups" "github.com/containerd/cgroups"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/containers/libpod/utils" "github.com/containers/libpod/utils"
@ -430,19 +431,19 @@ func (r *OCIRuntime) createOCIContainer(ctr *Container, cgroupParent string, res
if err == nil { if err == nil {
var ociErr ociError var ociErr ociError
if err := json.Unmarshal(data, &ociErr); err == nil { if err := json.Unmarshal(data, &ociErr); err == nil {
return errors.Wrapf(ErrOCIRuntime, "%s", strings.Trim(ociErr.Msg, "\n")) return errors.Wrapf(define.ErrOCIRuntime, "%s", strings.Trim(ociErr.Msg, "\n"))
} }
} }
} }
// If we failed to parse the JSON errors, then print the output as it is // If we failed to parse the JSON errors, then print the output as it is
if ss.si.Message != "" { if ss.si.Message != "" {
return errors.Wrapf(ErrOCIRuntime, "%s", ss.si.Message) return errors.Wrapf(define.ErrOCIRuntime, "%s", ss.si.Message)
} }
return errors.Wrapf(ErrInternal, "container create failed") return errors.Wrapf(define.ErrInternal, "container create failed")
} }
ctr.state.PID = ss.si.Pid ctr.state.PID = ss.si.Pid
case <-time.After(ContainerCreateTimeout): case <-time.After(ContainerCreateTimeout):
return errors.Wrapf(ErrInternal, "container creation timeout") return errors.Wrapf(define.ErrInternal, "container creation timeout")
} }
return nil return nil
} }

14
libpod/oci_unsupported.go
View File

@ -5,18 +5,20 @@ package libpod
import ( import (
"os" "os"
"os/exec" "os/exec"
"github.com/containers/libpod/libpod/define"
) )
func (r *OCIRuntime) moveConmonToCgroup(ctr *Container, cgroupParent string, cmd *exec.Cmd) error { func (r *OCIRuntime) moveConmonToCgroup(ctr *Container, cgroupParent string, cmd *exec.Cmd) error {
return ErrOSNotSupported return define.ErrOSNotSupported
} }
func newPipe() (parent *os.File, child *os.File, err error) { func newPipe() (parent *os.File, child *os.File, err error) {
return nil, nil, ErrNotImplemented return nil, nil, define.ErrNotImplemented
} }
func (r *OCIRuntime) createContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) { func (r *OCIRuntime) createContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (r *OCIRuntime) pathPackage() string { func (r *OCIRuntime) pathPackage() string {
@ -28,13 +30,13 @@ func (r *OCIRuntime) conmonPackage() string {
} }
func (r *OCIRuntime) createOCIContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) { func (r *OCIRuntime) createOCIContainer(ctr *Container, cgroupParent string, restoreOptions *ContainerCheckpointOptions) (err error) {
return ErrOSNotSupported return define.ErrOSNotSupported
} }
func (r *OCIRuntime) execStopContainer(ctr *Container, timeout uint) error { func (r *OCIRuntime) execStopContainer(ctr *Container, timeout uint) error {
return ErrOSNotSupported return define.ErrOSNotSupported
} }
func (r *OCIRuntime) stopContainer(ctr *Container, timeout uint) error { func (r *OCIRuntime) stopContainer(ctr *Container, timeout uint) error {
return ErrOSNotSupported return define.ErrOSNotSupported
} }

291
libpod/options.go
View File

File diff suppressed because it is too large Load Diff

9
libpod/pod.go
View File

@ -3,6 +3,7 @@ package libpod
import ( import (
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/lock" "github.com/containers/libpod/libpod/lock"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -190,7 +191,7 @@ func (p *Pod) CgroupPath() (string, error) {
// HasContainer checks if a container is present in the pod // HasContainer checks if a container is present in the pod
func (p *Pod) HasContainer(id string) (bool, error) { func (p *Pod) HasContainer(id string) (bool, error) {
if !p.valid { if !p.valid {
return false, ErrPodRemoved return false, define.ErrPodRemoved
} }
return p.runtime.state.PodHasContainer(p, id) return p.runtime.state.PodHasContainer(p, id)
@ -202,7 +203,7 @@ func (p *Pod) AllContainersByID() ([]string, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
return p.runtime.state.PodContainersByID(p) return p.runtime.state.PodContainersByID(p)
@ -211,7 +212,7 @@ func (p *Pod) AllContainersByID() ([]string, error) {
// AllContainers retrieves the containers in the pod // AllContainers retrieves the containers in the pod
func (p *Pod) AllContainers() ([]*Container, error) { func (p *Pod) AllContainers() ([]*Container, error) {
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
@ -280,7 +281,7 @@ func (p *Pod) GetPodStats(previousContainerStats map[string]*ContainerStats) (ma
newStats, err := c.GetContainerStats(prevStat) newStats, err := c.GetContainerStats(prevStat)
// If the container wasn't running, don't include it // If the container wasn't running, don't include it
// but also suppress the error // but also suppress the error
if err != nil && errors.Cause(err) != ErrCtrStateInvalid { if err != nil && errors.Cause(err) != define.ErrCtrStateInvalid {
return nil, err return nil, err
} }
if err == nil { if err == nil {

31
libpod/pod_api.go
View File

@ -3,6 +3,7 @@ package libpod
import ( import (
"context" "context"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -27,7 +28,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -47,7 +48,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
// If there are no containers without dependencies, we can't start // If there are no containers without dependencies, we can't start
// Error out // Error out
if len(graph.noDepNodes) == 0 { if len(graph.noDepNodes) == 0 {
return nil, errors.Wrapf(ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID()) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
} }
// Traverse the graph beginning at nodes with no dependencies // Traverse the graph beginning at nodes with no dependencies
@ -56,7 +57,7 @@ func (p *Pod) Start(ctx context.Context) (map[string]error, error) {
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error starting some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error starting some containers")
} }
defer p.newPodEvent(events.Start) defer p.newPodEvent(events.Start)
return nil, nil return nil, nil
@ -88,7 +89,7 @@ func (p *Pod) StopWithTimeout(ctx context.Context, cleanup bool, timeout int) (m
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -136,7 +137,7 @@ func (p *Pod) StopWithTimeout(ctx context.Context, cleanup bool, timeout int) (m
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error stopping some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error stopping some containers")
} }
defer p.newPodEvent(events.Stop) defer p.newPodEvent(events.Stop)
return nil, nil return nil, nil
@ -159,7 +160,7 @@ func (p *Pod) Pause() (map[string]error, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -195,7 +196,7 @@ func (p *Pod) Pause() (map[string]error, error) {
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error pausing some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error pausing some containers")
} }
defer p.newPodEvent(events.Pause) defer p.newPodEvent(events.Pause)
return nil, nil return nil, nil
@ -218,7 +219,7 @@ func (p *Pod) Unpause() (map[string]error, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -254,7 +255,7 @@ func (p *Pod) Unpause() (map[string]error, error) {
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error unpausing some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error unpausing some containers")
} }
defer p.newPodEvent(events.Unpause) defer p.newPodEvent(events.Unpause)
@ -279,7 +280,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -299,7 +300,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
// If there are no containers without dependencies, we can't start // If there are no containers without dependencies, we can't start
// Error out // Error out
if len(graph.noDepNodes) == 0 { if len(graph.noDepNodes) == 0 {
return nil, errors.Wrapf(ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID()) return nil, errors.Wrapf(define.ErrNoSuchCtr, "no containers in pod %s have no dependencies, cannot start pod", p.ID())
} }
// Traverse the graph beginning at nodes with no dependencies // Traverse the graph beginning at nodes with no dependencies
@ -308,7 +309,7 @@ func (p *Pod) Restart(ctx context.Context) (map[string]error, error) {
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error stopping some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error stopping some containers")
} }
p.newPodEvent(events.Stop) p.newPodEvent(events.Stop)
p.newPodEvent(events.Start) p.newPodEvent(events.Start)
@ -331,7 +332,7 @@ func (p *Pod) Kill(signal uint) (map[string]error, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)
@ -374,7 +375,7 @@ func (p *Pod) Kill(signal uint) (map[string]error, error) {
} }
if len(ctrErrors) > 0 { if len(ctrErrors) > 0 {
return ctrErrors, errors.Wrapf(ErrCtrExists, "error killing some containers") return ctrErrors, errors.Wrapf(define.ErrCtrExists, "error killing some containers")
} }
defer p.newPodEvent(events.Kill) defer p.newPodEvent(events.Kill)
return nil, nil return nil, nil
@ -387,7 +388,7 @@ func (p *Pod) Status() (map[string]ContainerStatus, error) {
defer p.lock.Unlock() defer p.lock.Unlock()
if !p.valid { if !p.valid {
return nil, ErrPodRemoved return nil, define.ErrPodRemoved
} }
allCtrs, err := p.runtime.state.PodContainers(p) allCtrs, err := p.runtime.state.PodContainers(p)

5
libpod/pod_internal.go
View File

@ -5,6 +5,7 @@ import (
"path/filepath" "path/filepath"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/storage/pkg/stringid" "github.com/containers/storage/pkg/stringid"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -52,7 +53,7 @@ func (p *Pod) refresh() error {
} }
if !p.valid { if !p.valid {
return ErrPodRemoved return define.ErrPodRemoved
} }
// Retrieve the pod's lock // Retrieve the pod's lock
@ -76,7 +77,7 @@ func (p *Pod) refresh() error {
logrus.Debugf("setting pod cgroup to %s", p.state.CgroupPath) logrus.Debugf("setting pod cgroup to %s", p.state.CgroupPath)
default: default:
return errors.Wrapf(ErrInvalidArg, "unknown cgroups manager %s specified", p.runtime.config.CgroupManager) return errors.Wrapf(define.ErrInvalidArg, "unknown cgroups manager %s specified", p.runtime.config.CgroupManager)
} }
} }

4
libpod/pod_top_unsupported.go
View File

@ -2,7 +2,9 @@
package libpod package libpod
import "github.com/containers/libpod/libpod/define"
// GetPodPidInformation is exclusive to linux // GetPodPidInformation is exclusive to linux
func (p *Pod) GetPodPidInformation(descriptors []string) ([]string, error) { func (p *Pod) GetPodPidInformation(descriptors []string) ([]string, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }

32
libpod/runtime.go
View File

@ -13,6 +13,7 @@ import (
"github.com/BurntSushi/toml" "github.com/BurntSushi/toml"
is "github.com/containers/image/storage" is "github.com/containers/image/storage"
"github.com/containers/image/types" "github.com/containers/image/types"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/libpod/lock" "github.com/containers/libpod/libpod/lock"
@ -75,9 +76,6 @@ var (
// DefaultInfraCommand to be run in an infra container // DefaultInfraCommand to be run in an infra container
DefaultInfraCommand = "/pause" DefaultInfraCommand = "/pause"
// DefaultInitPath is the default path to the container-init binary
DefaultInitPath = "/usr/libexec/podman/catatonit"
// DefaultSHMLockPath is the default path for SHM locks // DefaultSHMLockPath is the default path for SHM locks
DefaultSHMLockPath = "/libpod_lock" DefaultSHMLockPath = "/libpod_lock"
// DefaultRootlessSHMLockPath is the default path for rootless SHM locks // DefaultRootlessSHMLockPath is the default path for rootless SHM locks
@ -298,7 +296,7 @@ func defaultRuntimeConfig() (RuntimeConfig, error) {
ConmonEnvVars: []string{ ConmonEnvVars: []string{
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
}, },
InitPath: DefaultInitPath, InitPath: define.DefaultInitPath,
CgroupManager: SystemdCgroupsManager, CgroupManager: SystemdCgroupsManager,
StaticDir: filepath.Join(storeOpts.GraphRoot, "libpod"), StaticDir: filepath.Join(storeOpts.GraphRoot, "libpod"),
TmpDir: "", TmpDir: "",
@ -598,7 +596,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
break break
} }
if !foundConmon { if !foundConmon {
return errors.Wrapf(ErrInvalidArg, return errors.Wrapf(define.ErrInvalidArg,
"could not find a working conmon binary (configured options: %v)", "could not find a working conmon binary (configured options: %v)",
runtime.config.ConmonPath) runtime.config.ConmonPath)
} }
@ -621,7 +619,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
} }
runtime.state = state runtime.state = state
case SQLiteStateStore: case SQLiteStateStore:
return errors.Wrapf(ErrInvalidArg, "SQLite state is currently disabled") return errors.Wrapf(define.ErrInvalidArg, "SQLite state is currently disabled")
case BoltDBStateStore: case BoltDBStateStore:
dbPath := filepath.Join(runtime.config.StaticDir, "bolt_state.db") dbPath := filepath.Join(runtime.config.StaticDir, "bolt_state.db")
@ -631,7 +629,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
} }
runtime.state = state runtime.state = state
default: default:
return errors.Wrapf(ErrInvalidArg, "unrecognized state type passed") return errors.Wrapf(define.ErrInvalidArg, "unrecognized state type passed")
} }
// Grab config from the database so we can reset some defaults // Grab config from the database so we can reset some defaults
@ -791,7 +789,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
} }
if len(runtime.config.RuntimePath) == 0 { if len(runtime.config.RuntimePath) == 0 {
return errors.Wrapf(ErrInvalidArg, "empty runtime path array passed") return errors.Wrapf(define.ErrInvalidArg, "empty runtime path array passed")
} }
name := filepath.Base(runtime.config.RuntimePath[0]) name := filepath.Base(runtime.config.RuntimePath[0])
@ -816,7 +814,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
// Initialize remaining OCI runtimes // Initialize remaining OCI runtimes
for name, paths := range runtime.config.OCIRuntimes { for name, paths := range runtime.config.OCIRuntimes {
if len(paths) == 0 { if len(paths) == 0 {
return errors.Wrapf(ErrInvalidArg, "must provide at least 1 path to OCI runtime %s", name) return errors.Wrapf(define.ErrInvalidArg, "must provide at least 1 path to OCI runtime %s", name)
} }
supportsJSON := false supportsJSON := false
@ -865,7 +863,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
} else { } else {
ociRuntime, ok := runtime.ociRuntimes[runtime.config.OCIRuntime] ociRuntime, ok := runtime.ociRuntimes[runtime.config.OCIRuntime]
if !ok { if !ok {
return errors.Wrapf(ErrInvalidArg, "default OCI runtime %q not found", runtime.config.OCIRuntime) return errors.Wrapf(define.ErrInvalidArg, "default OCI runtime %q not found", runtime.config.OCIRuntime)
} }
runtime.defaultOCIRuntime = ociRuntime runtime.defaultOCIRuntime = ociRuntime
} }
@ -873,12 +871,12 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (err error) {
// Do we have at least one valid OCI runtime? // Do we have at least one valid OCI runtime?
if len(runtime.ociRuntimes) == 0 { if len(runtime.ociRuntimes) == 0 {
return errors.Wrapf(ErrInvalidArg, "no OCI runtime has been configured") return errors.Wrapf(define.ErrInvalidArg, "no OCI runtime has been configured")
} }
// Do we have a default runtime? // Do we have a default runtime?
if runtime.defaultOCIRuntime == nil { if runtime.defaultOCIRuntime == nil {
return errors.Wrapf(ErrInvalidArg, "no default OCI runtime was configured") return errors.Wrapf(define.ErrInvalidArg, "no default OCI runtime was configured")
} }
// Make the per-boot files directory if it does not exist // Make the per-boot files directory if it does not exist
@ -1030,7 +1028,7 @@ func (r *Runtime) GetConfig() (*RuntimeConfig, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
config := new(RuntimeConfig) config := new(RuntimeConfig)
@ -1052,7 +1050,7 @@ func (r *Runtime) Shutdown(force bool) error {
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return ErrRuntimeStopped return define.ErrRuntimeStopped
} }
r.valid = false r.valid = false
@ -1064,7 +1062,7 @@ func (r *Runtime) Shutdown(force bool) error {
logrus.Errorf("Error retrieving containers from database: %v", err) logrus.Errorf("Error retrieving containers from database: %v", err)
} else { } else {
for _, ctr := range ctrs { for _, ctr := range ctrs {
if err := ctr.StopWithTimeout(CtrRemoveTimeout); err != nil { if err := ctr.StopWithTimeout(define.CtrRemoveTimeout); err != nil {
logrus.Errorf("Error stopping container %s: %v", ctr.ID(), err) logrus.Errorf("Error stopping container %s: %v", ctr.ID(), err)
} }
} }
@ -1185,7 +1183,7 @@ func (r *Runtime) generateName() (string, error) {
if _, err := r.state.LookupContainer(name); err == nil { if _, err := r.state.LookupContainer(name); err == nil {
continue continue
} else { } else {
if errors.Cause(err) != ErrNoSuchCtr { if errors.Cause(err) != define.ErrNoSuchCtr {
return "", err return "", err
} }
} }
@ -1193,7 +1191,7 @@ func (r *Runtime) generateName() (string, error) {
if _, err := r.state.LookupPod(name); err == nil { if _, err := r.state.LookupPod(name); err == nil {
continue continue
} else { } else {
if errors.Cause(err) != ErrNoSuchPod { if errors.Cause(err) != define.ErrNoSuchPod {
return "", err return "", err
} }
} }

9
libpod/runtime_cstorage.go
View File

@ -1,6 +1,7 @@
package libpod package libpod
import ( import (
"github.com/containers/libpod/libpod/define"
"github.com/containers/storage" "github.com/containers/storage"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -56,7 +57,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
targetID, err := r.store.Lookup(idOrName) targetID, err := r.store.Lookup(idOrName)
if err != nil { if err != nil {
if err == storage.ErrLayerUnknown { if err == storage.ErrLayerUnknown {
return errors.Wrapf(ErrNoSuchCtr, "no container with ID or name %q found", idOrName) return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID or name %q found", idOrName)
} }
return errors.Wrapf(err, "error looking up container %q", idOrName) return errors.Wrapf(err, "error looking up container %q", idOrName)
} }
@ -66,7 +67,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
ctr, err := r.store.Container(targetID) ctr, err := r.store.Container(targetID)
if err != nil { if err != nil {
if err == storage.ErrContainerUnknown { if err == storage.ErrContainerUnknown {
return errors.Wrapf(ErrNoSuchCtr, "%q does not refer to a container", idOrName) return errors.Wrapf(define.ErrNoSuchCtr, "%q does not refer to a container", idOrName)
} }
return errors.Wrapf(err, "error retrieving container %q", idOrName) return errors.Wrapf(err, "error retrieving container %q", idOrName)
} }
@ -77,7 +78,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
return err return err
} }
if exists { if exists {
return errors.Wrapf(ErrCtrExists, "refusing to remove %q as it exists in libpod as container %s", idOrName, ctr.ID) return errors.Wrapf(define.ErrCtrExists, "refusing to remove %q as it exists in libpod as container %s", idOrName, ctr.ID)
} }
if !force { if !force {
@ -92,7 +93,7 @@ func (r *Runtime) RemoveStorageContainer(idOrName string, force bool) error {
return errors.Wrapf(err, "error looking up container %q mounts", idOrName) return errors.Wrapf(err, "error looking up container %q mounts", idOrName)
} }
if timesMounted > 0 { if timesMounted > 0 {
return errors.Wrapf(ErrCtrStateInvalid, "container %q is mounted and cannot be removed without using force", idOrName) return errors.Wrapf(define.ErrCtrStateInvalid, "container %q is mounted and cannot be removed without using force", idOrName)
} }
} else { } else {
if _, err := r.store.Unmount(ctr.ID, true); err != nil { if _, err := r.store.Unmount(ctr.ID, true); err != nil {

43
libpod/runtime_ctr.go
View File

@ -8,20 +8,17 @@ import (
"strings" "strings"
"time" "time"
config2 "github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/containers/storage/pkg/stringid" "github.com/containers/storage/pkg/stringid"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/opencontainers/runtime-tools/generate" "github.com/opencontainers/runtime-tools/generate"
opentracing "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
// CtrRemoveTimeout is the default number of seconds to wait after stopping a container
// before sending the kill signal
const CtrRemoveTimeout = 10
// Contains the public Runtime API for containers // Contains the public Runtime API for containers
// A CtrCreateOption is a functional option which alters the Container created // A CtrCreateOption is a functional option which alters the Container created
@ -38,7 +35,7 @@ func (r *Runtime) NewContainer(ctx context.Context, rSpec *spec.Spec, options ..
r.lock.Lock() r.lock.Lock()
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, config2.ErrRuntimeStopped
} }
return r.newContainer(ctx, rSpec, options...) return r.newContainer(ctx, rSpec, options...)
} }
@ -48,7 +45,7 @@ func (r *Runtime) RestoreContainer(ctx context.Context, rSpec *spec.Spec, config
r.lock.Lock() r.lock.Lock()
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, config2.ErrRuntimeStopped
} }
ctr, err := r.initContainerVariables(rSpec, config) ctr, err := r.initContainerVariables(rSpec, config)
@ -60,7 +57,7 @@ func (r *Runtime) RestoreContainer(ctx context.Context, rSpec *spec.Spec, config
func (r *Runtime) initContainerVariables(rSpec *spec.Spec, config *ContainerConfig) (c *Container, err error) { func (r *Runtime) initContainerVariables(rSpec *spec.Spec, config *ContainerConfig) (c *Container, err error) {
if rSpec == nil { if rSpec == nil {
return nil, errors.Wrapf(ErrInvalidArg, "must provide a valid runtime spec to create container") return nil, errors.Wrapf(config2.ErrInvalidArg, "must provide a valid runtime spec to create container")
} }
ctr := new(Container) ctr := new(Container)
ctr.config = new(ContainerConfig) ctr.config = new(ContainerConfig)
@ -92,7 +89,7 @@ func (r *Runtime) initContainerVariables(rSpec *spec.Spec, config *ContainerConf
ctr.state.BindMounts = make(map[string]string) ctr.state.BindMounts = make(map[string]string)
ctr.config.StopTimeout = CtrRemoveTimeout ctr.config.StopTimeout = config2.CtrRemoveTimeout
ctr.config.OCIRuntime = r.defaultOCIRuntime.name ctr.config.OCIRuntime = r.defaultOCIRuntime.name
@ -144,7 +141,7 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
} else { } else {
ociRuntime, ok := r.ociRuntimes[ctr.config.OCIRuntime] ociRuntime, ok := r.ociRuntimes[ctr.config.OCIRuntime]
if !ok { if !ok {
return nil, errors.Wrapf(ErrInvalidArg, "requested OCI runtime %s is not available", ctr.config.OCIRuntime) return nil, errors.Wrapf(config2.ErrInvalidArg, "requested OCI runtime %s is not available", ctr.config.OCIRuntime)
} }
ctr.ociRuntime = ociRuntime ctr.ociRuntime = ociRuntime
} }
@ -177,14 +174,14 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
return nil, errors.Wrapf(err, "error retrieving pod %s cgroup", pod.ID()) return nil, errors.Wrapf(err, "error retrieving pod %s cgroup", pod.ID())
} }
if podCgroup == "" { if podCgroup == "" {
return nil, errors.Wrapf(ErrInternal, "pod %s cgroup is not set", pod.ID()) return nil, errors.Wrapf(config2.ErrInternal, "pod %s cgroup is not set", pod.ID())
} }
ctr.config.CgroupParent = podCgroup ctr.config.CgroupParent = podCgroup
} else { } else {
ctr.config.CgroupParent = CgroupfsDefaultCgroupParent ctr.config.CgroupParent = CgroupfsDefaultCgroupParent
} }
} else if strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") { } else if strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") {
return nil, errors.Wrapf(ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs") return nil, errors.Wrapf(config2.ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
} }
case SystemdCgroupsManager: case SystemdCgroupsManager:
if ctr.config.CgroupParent == "" { if ctr.config.CgroupParent == "" {
@ -198,10 +195,10 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
ctr.config.CgroupParent = SystemdDefaultCgroupParent ctr.config.CgroupParent = SystemdDefaultCgroupParent
} }
} else if len(ctr.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") { } else if len(ctr.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(ctr.config.CgroupParent), ".slice") {
return nil, errors.Wrapf(ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups") return nil, errors.Wrapf(config2.ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
} }
default: default:
return nil, errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager) return nil, errors.Wrapf(config2.ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
} }
if restore { if restore {
@ -241,7 +238,7 @@ func (r *Runtime) setupContainer(ctx context.Context, ctr *Container, restore bo
if err == nil { if err == nil {
// The volume exists, we're good // The volume exists, we're good
continue continue
} else if errors.Cause(err) != ErrNoSuchVolume { } else if errors.Cause(err) != config2.ErrNoSuchVolume {
return nil, errors.Wrapf(err, "error retrieving named volume %s for new container", vol.Name) return nil, errors.Wrapf(err, "error retrieving named volume %s for new container", vol.Name)
} }
@ -355,7 +352,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
} }
if !r.valid { if !r.valid {
return ErrRuntimeStopped return config2.ErrRuntimeStopped
} }
// Update the container to get current state // Update the container to get current state
@ -413,7 +410,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
} }
if len(deps) != 0 { if len(deps) != 0 {
depsStr := strings.Join(deps, ", ") depsStr := strings.Join(deps, ", ")
return errors.Wrapf(ErrCtrExists, "container %s has dependent containers which must be removed before it: %s", c.ID(), depsStr) return errors.Wrapf(config2.ErrCtrExists, "container %s has dependent containers which must be removed before it: %s", c.ID(), depsStr)
} }
} }
@ -496,7 +493,7 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
if !volume.IsCtrSpecific() { if !volume.IsCtrSpecific() {
continue continue
} }
if err := runtime.removeVolume(ctx, volume, false); err != nil && err != ErrNoSuchVolume && err != ErrVolumeBeingUsed { if err := runtime.removeVolume(ctx, volume, false); err != nil && err != config2.ErrNoSuchVolume && err != config2.ErrVolumeBeingUsed {
logrus.Errorf("cleanup volume (%s): %v", v, err) logrus.Errorf("cleanup volume (%s): %v", v, err)
} }
} }
@ -511,7 +508,7 @@ func (r *Runtime) GetContainer(id string) (*Container, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, config2.ErrRuntimeStopped
} }
return r.state.Container(id) return r.state.Container(id)
@ -523,7 +520,7 @@ func (r *Runtime) HasContainer(id string) (bool, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return false, ErrRuntimeStopped return false, config2.ErrRuntimeStopped
} }
return r.state.HasContainer(id) return r.state.HasContainer(id)
@ -536,7 +533,7 @@ func (r *Runtime) LookupContainer(idOrName string) (*Container, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, config2.ErrRuntimeStopped
} }
return r.state.LookupContainer(idOrName) return r.state.LookupContainer(idOrName)
} }
@ -550,7 +547,7 @@ func (r *Runtime) GetContainers(filters ...ContainerFilter) ([]*Container, error
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, config2.ErrRuntimeStopped
} }
ctrs, err := r.state.AllContainers() ctrs, err := r.state.AllContainers()
@ -611,7 +608,7 @@ func (r *Runtime) GetLatestContainer() (*Container, error) {
return nil, errors.Wrapf(err, "unable to find latest container") return nil, errors.Wrapf(err, "unable to find latest container")
} }
if len(ctrs) == 0 { if len(ctrs) == 0 {
return nil, ErrNoSuchCtr return nil, config2.ErrNoSuchCtr
} }
for containerIndex, ctr := range ctrs { for containerIndex, ctr := range ctrs {
createdTime := ctr.config.CreatedTime createdTime := ctr.config.CreatedTime

3
libpod/runtime_img.go
View File

@ -10,6 +10,7 @@ import (
"os" "os"
"github.com/containers/buildah/imagebuildah" "github.com/containers/buildah/imagebuildah"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/containers/storage" "github.com/containers/storage"
@ -31,7 +32,7 @@ func (r *Runtime) RemoveImage(ctx context.Context, img *image.Image, force bool)
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return "", ErrRuntimeStopped return "", define.ErrRuntimeStopped
} }
// Get all containers, filter to only those using the image, and remove those containers // Get all containers, filter to only those using the image, and remove those containers

19
libpod/runtime_pod.go
View File

@ -4,6 +4,7 @@ import (
"context" "context"
"time" "time"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
@ -30,7 +31,7 @@ func (r *Runtime) RemovePod(ctx context.Context, p *Pod, removeCtrs, force bool)
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return ErrRuntimeStopped return define.ErrRuntimeStopped
} }
if !p.valid { if !p.valid {
@ -53,7 +54,7 @@ func (r *Runtime) GetPod(id string) (*Pod, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
return r.state.Pod(id) return r.state.Pod(id)
@ -65,7 +66,7 @@ func (r *Runtime) HasPod(id string) (bool, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return false, ErrRuntimeStopped return false, define.ErrRuntimeStopped
} }
return r.state.HasPod(id) return r.state.HasPod(id)
@ -78,7 +79,7 @@ func (r *Runtime) LookupPod(idOrName string) (*Pod, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
return r.state.LookupPod(idOrName) return r.state.LookupPod(idOrName)
@ -93,7 +94,7 @@ func (r *Runtime) Pods(filters ...PodFilter) ([]*Pod, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
pods, err := r.state.AllPods() pods, err := r.state.AllPods()
@ -122,7 +123,7 @@ func (r *Runtime) GetAllPods() ([]*Pod, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
return r.state.AllPods() return r.state.AllPods()
@ -137,7 +138,7 @@ func (r *Runtime) GetLatestPod() (*Pod, error) {
return nil, errors.Wrapf(err, "unable to get all pods") return nil, errors.Wrapf(err, "unable to get all pods")
} }
if len(pods) == 0 { if len(pods) == 0 {
return nil, ErrNoSuchPod return nil, define.ErrNoSuchPod
} }
for podIndex, pod := range pods { for podIndex, pod := range pods {
createdTime := pod.config.CreatedTime createdTime := pod.config.CreatedTime
@ -159,7 +160,7 @@ func (r *Runtime) GetRunningPods() ([]*Pod, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
containers, err := r.GetRunningContainers() containers, err := r.GetRunningContainers()
if err != nil { if err != nil {
@ -171,7 +172,7 @@ func (r *Runtime) GetRunningPods() ([]*Pod, error) {
pods = append(pods, c.PodID()) pods = append(pods, c.PodID())
pod, err := r.GetPod(c.PodID()) pod, err := r.GetPod(c.PodID())
if err != nil { if err != nil {
if errors.Cause(err) == ErrPodRemoved || errors.Cause(err) == ErrNoSuchPod { if errors.Cause(err) == define.ErrPodRemoved || errors.Cause(err) == define.ErrNoSuchPod {
continue continue
} }
return nil, err return nil, err

3
libpod/runtime_pod_infra_linux.go
View File

@ -6,6 +6,7 @@ import (
"context" "context"
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/rootless" "github.com/containers/libpod/pkg/rootless"
"github.com/opencontainers/image-spec/specs-go/v1" "github.com/opencontainers/image-spec/specs-go/v1"
@ -104,7 +105,7 @@ func (r *Runtime) makeInfraContainer(ctx context.Context, p *Pod, imgName, imgID
// containers in the pod. // containers in the pod.
func (r *Runtime) createInfraContainer(ctx context.Context, p *Pod) (*Container, error) { func (r *Runtime) createInfraContainer(ctx context.Context, p *Pod) (*Container, error) {
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
newImage, err := r.ImageRuntime().New(ctx, r.config.InfraImage, "", "", nil, nil, image.SigningOptions{}, false, nil) newImage, err := r.ImageRuntime().New(ctx, r.config.InfraImage, "", "", nil, nil, image.SigningOptions{}, false, nil)

13
libpod/runtime_pod_linux.go
View File

@ -10,6 +10,7 @@ import (
"strings" "strings"
"github.com/containerd/cgroups" "github.com/containerd/cgroups"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -22,7 +23,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
pod, err := newPod(r) pod, err := newPod(r)
@ -66,7 +67,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
if pod.config.CgroupParent == "" { if pod.config.CgroupParent == "" {
pod.config.CgroupParent = CgroupfsDefaultCgroupParent pod.config.CgroupParent = CgroupfsDefaultCgroupParent
} else if strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") { } else if strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") {
return nil, errors.Wrapf(ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs") return nil, errors.Wrapf(define.ErrInvalidArg, "systemd slice received as cgroup parent when using cgroupfs")
} }
// If we are set to use pod cgroups, set the cgroup parent that // If we are set to use pod cgroups, set the cgroup parent that
// all containers in the pod will share // all containers in the pod will share
@ -79,7 +80,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
if pod.config.CgroupParent == "" { if pod.config.CgroupParent == "" {
pod.config.CgroupParent = SystemdDefaultCgroupParent pod.config.CgroupParent = SystemdDefaultCgroupParent
} else if len(pod.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") { } else if len(pod.config.CgroupParent) < 6 || !strings.HasSuffix(path.Base(pod.config.CgroupParent), ".slice") {
return nil, errors.Wrapf(ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups") return nil, errors.Wrapf(define.ErrInvalidArg, "did not receive systemd slice as cgroup parent when using systemd to manage cgroups")
} }
// If we are set to use pod cgroups, set the cgroup parent that // If we are set to use pod cgroups, set the cgroup parent that
// all containers in the pod will share // all containers in the pod will share
@ -91,7 +92,7 @@ func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod,
pod.state.CgroupPath = cgroupPath pod.state.CgroupPath = cgroupPath
} }
default: default:
return nil, errors.Wrapf(ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager) return nil, errors.Wrapf(define.ErrInvalidArg, "unsupported CGroup manager: %s - cannot validate cgroup parent", r.config.CgroupManager)
} }
if pod.config.UsePodCgroup { if pod.config.UsePodCgroup {
@ -146,7 +147,7 @@ func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool)
force = true force = true
} }
if !removeCtrs && numCtrs > 0 { if !removeCtrs && numCtrs > 0 {
return errors.Wrapf(ErrCtrExists, "pod %s contains containers and cannot be removed", p.ID()) return errors.Wrapf(define.ErrCtrExists, "pod %s contains containers and cannot be removed", p.ID())
} }
// Go through and lock all containers so we can operate on them all at // Go through and lock all containers so we can operate on them all at
@ -290,7 +291,7 @@ func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool)
// keep going so we make sure to evict the pod before // keep going so we make sure to evict the pod before
// ending up with an inconsistent state. // ending up with an inconsistent state.
if removalErr == nil { if removalErr == nil {
removalErr = errors.Wrapf(ErrInternal, "unrecognized cgroup manager %s when removing pod %s cgroups", p.runtime.config.CgroupManager, p.ID()) removalErr = errors.Wrapf(define.ErrInternal, "unrecognized cgroup manager %s when removing pod %s cgroups", p.runtime.config.CgroupManager, p.ID())
} else { } else {
logrus.Errorf("Unknown cgroups manager %s specified - cannot remove pod %s cgroup", p.runtime.config.CgroupManager, p.ID()) logrus.Errorf("Unknown cgroups manager %s specified - cannot remove pod %s cgroup", p.runtime.config.CgroupManager, p.ID())
} }

6
libpod/runtime_pod_unsupported.go
View File

@ -4,13 +4,15 @@ package libpod
import ( import (
"context" "context"
"github.com/containers/libpod/libpod/define"
) )
// NewPod makes a new, empty pod // NewPod makes a new, empty pod
func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod, error) { func (r *Runtime) NewPod(ctx context.Context, options ...PodCreateOption) (*Pod, error) {
return nil, ErrOSNotSupported return nil, define.ErrOSNotSupported
} }
func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool) error { func (r *Runtime) removePod(ctx context.Context, p *Pod, removeCtrs, force bool) error {
return ErrOSNotSupported return define.ErrOSNotSupported
} }

13
libpod/runtime_volume.go
View File

@ -4,6 +4,7 @@ import (
"context" "context"
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -26,7 +27,7 @@ func (r *Runtime) RemoveVolume(ctx context.Context, v *Volume, force bool) error
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return ErrRuntimeStopped return define.ErrRuntimeStopped
} }
if !v.valid { if !v.valid {
@ -77,7 +78,7 @@ func (r *Runtime) GetVolume(name string) (*Volume, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
vol, err := r.state.Volume(name) vol, err := r.state.Volume(name)
@ -103,7 +104,7 @@ func (r *Runtime) HasVolume(name string) (bool, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return false, ErrRuntimeStopped return false, define.ErrRuntimeStopped
} }
return r.state.HasVolume(name) return r.state.HasVolume(name)
@ -118,7 +119,7 @@ func (r *Runtime) Volumes(filters ...VolumeFilter) ([]*Volume, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
vols, err := r.state.AllVolumes() vols, err := r.state.AllVolumes()
@ -147,7 +148,7 @@ func (r *Runtime) GetAllVolumes() ([]*Volume, error) {
defer r.lock.RUnlock() defer r.lock.RUnlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
return r.state.AllVolumes() return r.state.AllVolumes()
@ -167,7 +168,7 @@ func (r *Runtime) PruneVolumes(ctx context.Context) ([]string, []error) {
for _, vol := range vols { for _, vol := range vols {
if err := r.RemoveVolume(ctx, vol, false); err != nil { if err := r.RemoveVolume(ctx, vol, false); err != nil {
if errors.Cause(err) != ErrVolumeBeingUsed && errors.Cause(err) != ErrVolumeRemoved { if errors.Cause(err) != define.ErrVolumeBeingUsed && errors.Cause(err) != define.ErrVolumeRemoved {
pruneErrors = append(pruneErrors, err) pruneErrors = append(pruneErrors, err)
} }
continue continue

9
libpod/runtime_volume_linux.go
View File

@ -8,6 +8,7 @@ import (
"path/filepath" "path/filepath"
"strings" "strings"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/storage/pkg/stringid" "github.com/containers/storage/pkg/stringid"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -20,7 +21,7 @@ func (r *Runtime) NewVolume(ctx context.Context, options ...VolumeCreateOption)
defer r.lock.Unlock() defer r.lock.Unlock()
if !r.valid { if !r.valid {
return nil, ErrRuntimeStopped return nil, define.ErrRuntimeStopped
} }
return r.newVolume(ctx, options...) return r.newVolume(ctx, options...)
} }
@ -86,7 +87,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
if ok, _ := r.state.HasVolume(v.Name()); !ok { if ok, _ := r.state.HasVolume(v.Name()); !ok {
return nil return nil
} }
return ErrVolumeRemoved return define.ErrVolumeRemoved
} }
deps, err := r.state.VolumeInUse(v) deps, err := r.state.VolumeInUse(v)
@ -96,7 +97,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
if len(deps) != 0 { if len(deps) != 0 {
depsStr := strings.Join(deps, ", ") depsStr := strings.Join(deps, ", ")
if !force { if !force {
return errors.Wrapf(ErrVolumeBeingUsed, "volume %s is being used by the following container(s): %s", v.Name(), depsStr) return errors.Wrapf(define.ErrVolumeBeingUsed, "volume %s is being used by the following container(s): %s", v.Name(), depsStr)
} }
// We need to remove all containers using the volume // We need to remove all containers using the volume
@ -105,7 +106,7 @@ func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error
if err != nil { if err != nil {
// If the container's removed, no point in // If the container's removed, no point in
// erroring. // erroring.
if errors.Cause(err) == ErrNoSuchCtr || errors.Cause(err) == ErrCtrRemoved { if errors.Cause(err) == define.ErrNoSuchCtr || errors.Cause(err) == define.ErrCtrRemoved {
continue continue
} }

8
libpod/runtime_volume_unsupported.go
View File

@ -4,16 +4,18 @@ package libpod
import ( import (
"context" "context"
"github.com/containers/libpod/libpod/define"
) )
func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error { func (r *Runtime) removeVolume(ctx context.Context, v *Volume, force bool) error {
return ErrNotImplemented return define.ErrNotImplemented
} }
func (r *Runtime) newVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) { func (r *Runtime) newVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }
func (r *Runtime) NewVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) { func (r *Runtime) NewVolume(ctx context.Context, options ...VolumeCreateOption) (*Volume, error) {
return nil, ErrNotImplemented return nil, define.ErrNotImplemented
} }

3
libpod/stats.go
View File

@ -8,6 +8,7 @@ import (
"time" "time"
"github.com/containerd/cgroups" "github.com/containerd/cgroups"
"github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
@ -26,7 +27,7 @@ func (c *Container) GetContainerStats(previousStats *ContainerStats) (*Container
} }
if c.state.State != ContainerStateRunning { if c.state.State != ContainerStateRunning {
return stats, ErrCtrStateInvalid return stats, define.ErrCtrStateInvalid
} }
cgroupPath, err := c.CGroupPath() cgroupPath, err := c.CGroupPath()

4
libpod/stats_unsupported.go
View File

@ -2,7 +2,9 @@
package libpod package libpod
import "github.com/containers/libpod/libpod/define"
// GetContainerStats gets the running stats for a given container // GetContainerStats gets the running stats for a given container
func (c *Container) GetContainerStats(previousStats *ContainerStats) (*ContainerStats, error) { func (c *Container) GetContainerStats(previousStats *ContainerStats) (*ContainerStats, error) {
return nil, ErrOSNotSupported return nil, define.ErrOSNotSupported
} }

19
libpod/storage.go
View File

@ -6,9 +6,10 @@ import (
istorage "github.com/containers/image/storage" istorage "github.com/containers/image/storage"
"github.com/containers/image/types" "github.com/containers/image/types"
"github.com/containers/libpod/libpod/define"
"github.com/containers/storage" "github.com/containers/storage"
"github.com/opencontainers/image-spec/specs-go/v1" "github.com/opencontainers/image-spec/specs-go/v1"
opentracing "github.com/opentracing/opentracing-go" "github.com/opentracing/opentracing-go"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
@ -71,7 +72,7 @@ func (r *storageService) CreateContainerStorage(ctx context.Context, systemConte
if imageName != "" { if imageName != "" {
var ref types.ImageReference var ref types.ImageReference
if containerName == "" { if containerName == "" {
return ContainerInfo{}, ErrEmptyID return ContainerInfo{}, define.ErrEmptyID
} }
// Check if we have the specified image. // Check if we have the specified image.
ref, err := istorage.Transport.ParseStoreReference(r.store, imageID) ref, err := istorage.Transport.ParseStoreReference(r.store, imageID)
@ -175,7 +176,7 @@ func (r *storageService) CreateContainerStorage(ctx context.Context, systemConte
func (r *storageService) DeleteContainer(idOrName string) error { func (r *storageService) DeleteContainer(idOrName string) error {
if idOrName == "" { if idOrName == "" {
return ErrEmptyID return define.ErrEmptyID
} }
container, err := r.store.Container(idOrName) container, err := r.store.Container(idOrName)
if err != nil { if err != nil {
@ -214,7 +215,7 @@ func (r *storageService) MountContainerImage(idOrName string) (string, error) {
container, err := r.store.Container(idOrName) container, err := r.store.Container(idOrName)
if err != nil { if err != nil {
if errors.Cause(err) == storage.ErrContainerUnknown { if errors.Cause(err) == storage.ErrContainerUnknown {
return "", ErrNoSuchCtr return "", define.ErrNoSuchCtr
} }
return "", err return "", err
} }
@ -233,7 +234,7 @@ func (r *storageService) MountContainerImage(idOrName string) (string, error) {
func (r *storageService) UnmountContainerImage(idOrName string, force bool) (bool, error) { func (r *storageService) UnmountContainerImage(idOrName string, force bool) (bool, error) {
if idOrName == "" { if idOrName == "" {
return false, ErrEmptyID return false, define.ErrEmptyID
} }
container, err := r.store.Container(idOrName) container, err := r.store.Container(idOrName)
if err != nil { if err != nil {
@ -260,7 +261,7 @@ func (r *storageService) UnmountContainerImage(idOrName string, force bool) (boo
func (r *storageService) MountedContainerImage(idOrName string) (int, error) { func (r *storageService) MountedContainerImage(idOrName string) (int, error) {
if idOrName == "" { if idOrName == "" {
return 0, ErrEmptyID return 0, define.ErrEmptyID
} }
container, err := r.store.Container(idOrName) container, err := r.store.Container(idOrName)
if err != nil { if err != nil {
@ -277,7 +278,7 @@ func (r *storageService) GetMountpoint(id string) (string, error) {
container, err := r.store.Container(id) container, err := r.store.Container(id)
if err != nil { if err != nil {
if errors.Cause(err) == storage.ErrContainerUnknown { if errors.Cause(err) == storage.ErrContainerUnknown {
return "", ErrNoSuchCtr return "", define.ErrNoSuchCtr
} }
return "", err return "", err
} }
@ -293,7 +294,7 @@ func (r *storageService) GetWorkDir(id string) (string, error) {
container, err := r.store.Container(id) container, err := r.store.Container(id)
if err != nil { if err != nil {
if errors.Cause(err) == storage.ErrContainerUnknown { if errors.Cause(err) == storage.ErrContainerUnknown {
return "", ErrNoSuchCtr return "", define.ErrNoSuchCtr
} }
return "", err return "", err
} }
@ -304,7 +305,7 @@ func (r *storageService) GetRunDir(id string) (string, error) {
container, err := r.store.Container(id) container, err := r.store.Container(id)
if err != nil { if err != nil {
if errors.Cause(err) == storage.ErrContainerUnknown { if errors.Cause(err) == storage.ErrContainerUnknown {
return "", ErrNoSuchCtr return "", define.ErrNoSuchCtr
} }
return "", err return "", err
} }

9
libpod/util.go
View File

@ -11,6 +11,7 @@ import (
"github.com/containers/image/signature" "github.com/containers/image/signature"
"github.com/containers/image/types" "github.com/containers/image/types"
"github.com/containers/libpod/libpod/define"
"github.com/fsnotify/fsnotify" "github.com/fsnotify/fsnotify"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -126,7 +127,7 @@ func WaitForFile(path string, chWait chan error, timeout time.Duration) (bool, e
return false, errors.Wrapf(err, "checking file %s", path) return false, errors.Wrapf(err, "checking file %s", path)
} }
case <-timeoutChan: case <-timeoutChan:
return false, errors.Wrapf(ErrInternal, "timed out waiting for file %s", path) return false, errors.Wrapf(define.ErrInternal, "timed out waiting for file %s", path)
} }
} }
} }
@ -156,15 +157,15 @@ func sortMounts(m []spec.Mount) []spec.Mount {
func validPodNSOption(p *Pod, ctrPod string) error { func validPodNSOption(p *Pod, ctrPod string) error {
if p == nil { if p == nil {
return errors.Wrapf(ErrInvalidArg, "pod passed in was nil. Container may not be associated with a pod") return errors.Wrapf(define.ErrInvalidArg, "pod passed in was nil. Container may not be associated with a pod")
} }
if ctrPod == "" { if ctrPod == "" {
return errors.Wrapf(ErrInvalidArg, "container is not a member of any pod") return errors.Wrapf(define.ErrInvalidArg, "container is not a member of any pod")
} }
if ctrPod != p.ID() { if ctrPod != p.ID() {
return errors.Wrapf(ErrInvalidArg, "pod passed in is not the pod the container is associated with") return errors.Wrapf(define.ErrInvalidArg, "pod passed in is not the pod the container is associated with")
} }
return nil return nil
} }

3
libpod/util_linux.go
View File

@ -7,6 +7,7 @@ import (
"strings" "strings"
"github.com/containerd/cgroups" "github.com/containerd/cgroups"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/opencontainers/selinux/go-selinux/label" "github.com/opencontainers/selinux/go-selinux/label"
@ -61,7 +62,7 @@ func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) {
const sliceSuffix = ".slice" const sliceSuffix = ".slice"
if !strings.HasSuffix(baseSlice, sliceSuffix) { if !strings.HasSuffix(baseSlice, sliceSuffix) {
return "", errors.Wrapf(ErrInvalidArg, "cannot assemble cgroup path with base %q - must end in .slice", baseSlice) return "", errors.Wrapf(define.ErrInvalidArg, "cannot assemble cgroup path with base %q - must end in .slice", baseSlice)
} }
noSlice := strings.TrimSuffix(baseSlice, sliceSuffix) noSlice := strings.TrimSuffix(baseSlice, sliceSuffix)

11
libpod/util_unsupported.go
View File

@ -3,27 +3,28 @@
package libpod package libpod
import ( import (
"github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
func systemdSliceFromPath(parent, name string) (string, error) { func systemdSliceFromPath(parent, name string) (string, error) {
return "", errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes") return "", errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
} }
func makeSystemdCgroup(path string) error { func makeSystemdCgroup(path string) error {
return errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes") return errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
} }
func deleteSystemdCgroup(path string) error { func deleteSystemdCgroup(path string) error {
return errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes") return errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
} }
func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) { func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) {
return "", errors.Wrapf(ErrOSNotSupported, "cgroups are not supported on non-linux OSes") return "", errors.Wrapf(define.ErrOSNotSupported, "cgroups are not supported on non-linux OSes")
} }
// LabelVolumePath takes a mount path for a volume and gives it an // LabelVolumePath takes a mount path for a volume and gives it an
// selinux label of either shared or not // selinux label of either shared or not
func LabelVolumePath(path string, shared bool) error { func LabelVolumePath(path string, shared bool) error {
return ErrNotImplemented return define.ErrNotImplemented
} }

27
pkg/adapter/containers.go
View File

@ -21,6 +21,7 @@ import (
"github.com/containers/libpod/cmd/podman/cliconfig" "github.com/containers/libpod/cmd/podman/cliconfig"
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/adapter/shortcuts" "github.com/containers/libpod/pkg/adapter/shortcuts"
"github.com/containers/libpod/pkg/systemdgen" "github.com/containers/libpod/pkg/systemdgen"
@ -96,10 +97,10 @@ func (r *LocalRuntime) StopContainers(ctx context.Context, cli *cliconfig.StopVa
func() error { func() error {
err := c.StopWithTimeout(*timeout) err := c.StopWithTimeout(*timeout)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrCtrStopped { if errors.Cause(err) == define.ErrCtrStopped {
logrus.Debugf("Container %s is already stopped", c.ID()) logrus.Debugf("Container %s is already stopped", c.ID())
return nil return nil
} else if cli.All && errors.Cause(err) == libpod.ErrCtrStateInvalid { } else if cli.All && errors.Cause(err) == define.ErrCtrStateInvalid {
logrus.Debugf("Container %s is not running, could not stop", c.ID()) logrus.Debugf("Container %s is not running, could not stop", c.ID())
return nil return nil
} }
@ -165,7 +166,7 @@ func (r *LocalRuntime) InitContainers(ctx context.Context, cli *cliconfig.InitVa
err := ctr.Init(ctx) err := ctr.Init(ctx)
if err != nil { if err != nil {
// If we're initializing all containers, ignore invalid state errors // If we're initializing all containers, ignore invalid state errors
if cli.All && errors.Cause(err) == libpod.ErrCtrStateInvalid { if cli.All && errors.Cause(err) == define.ErrCtrStateInvalid {
return nil return nil
} }
return err return err
@ -376,7 +377,7 @@ func (r *LocalRuntime) Run(ctx context.Context, c *cliconfig.RunValues, exitCode
case "stdin": case "stdin":
inputStream = os.Stdin inputStream = os.Stdin
default: default:
return exitCode, errors.Wrapf(libpod.ErrInvalidArg, "invalid stream %q for --attach - must be one of stdin, stdout, or stderr", stream) return exitCode, errors.Wrapf(define.ErrInvalidArg, "invalid stream %q for --attach - must be one of stdin, stdout, or stderr", stream)
} }
} }
} }
@ -385,7 +386,7 @@ func (r *LocalRuntime) Run(ctx context.Context, c *cliconfig.RunValues, exitCode
// We've manually detached from the container // We've manually detached from the container
// Do not perform cleanup, or wait for container exit code // Do not perform cleanup, or wait for container exit code
// Just exit immediately // Just exit immediately
if errors.Cause(err) == libpod.ErrDetach { if errors.Cause(err) == define.ErrDetach {
exitCode = 0 exitCode = 0
return exitCode, nil return exitCode, nil
} }
@ -403,7 +404,7 @@ func (r *LocalRuntime) Run(ctx context.Context, c *cliconfig.RunValues, exitCode
} }
if ecode, err := ctr.Wait(); err != nil { if ecode, err := ctr.Wait(); err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
// The container may have been removed // The container may have been removed
// Go looking for an exit file // Go looking for an exit file
config, err := r.Runtime.GetConfig() config, err := r.Runtime.GetConfig()
@ -496,19 +497,25 @@ func (r *LocalRuntime) Attach(ctx context.Context, c *cliconfig.AttachValues) er
inputStream = nil inputStream = nil
} }
// If the container is in a pod, also set to recursively start dependencies // If the container is in a pod, also set to recursively start dependencies
if err := StartAttachCtr(ctx, ctr, os.Stdout, os.Stderr, inputStream, c.DetachKeys, c.SigProxy, false, ctr.PodID() != ""); err != nil && errors.Cause(err) != libpod.ErrDetach { if err := StartAttachCtr(ctx, ctr, os.Stdout, os.Stderr, inputStream, c.DetachKeys, c.SigProxy, false, ctr.PodID() != ""); err != nil && errors.Cause(err) != define.ErrDetach {
return errors.Wrapf(err, "error attaching to container %s", ctr.ID()) return errors.Wrapf(err, "error attaching to container %s", ctr.ID())
} }
return nil return nil
} }
// Checkpoint one or more containers // Checkpoint one or more containers
func (r *LocalRuntime) Checkpoint(c *cliconfig.CheckpointValues, options libpod.ContainerCheckpointOptions) error { func (r *LocalRuntime) Checkpoint(c *cliconfig.CheckpointValues) error {
var ( var (
containers []*libpod.Container containers []*libpod.Container
err, lastError error err, lastError error
) )
options := libpod.ContainerCheckpointOptions{
Keep: c.Keep,
KeepRunning: c.LeaveRunning,
TCPEstablished: c.TcpEstablished,
TargetFile: c.Export,
}
if c.All { if c.All {
containers, err = r.Runtime.GetRunningContainers() containers, err = r.Runtime.GetRunningContainers()
} else { } else {
@ -610,7 +617,7 @@ func (r *LocalRuntime) Start(ctx context.Context, c *cliconfig.StartValues, sigP
// attach to the container and also start it not already running // attach to the container and also start it not already running
// If the container is in a pod, also set to recursively start dependencies // If the container is in a pod, also set to recursively start dependencies
err = StartAttachCtr(ctx, ctr.Container, os.Stdout, os.Stderr, inputStream, c.DetachKeys, sigProxy, !ctrRunning, ctr.PodID() != "") err = StartAttachCtr(ctx, ctr.Container, os.Stdout, os.Stderr, inputStream, c.DetachKeys, sigProxy, !ctrRunning, ctr.PodID() != "")
if errors.Cause(err) == libpod.ErrDetach { if errors.Cause(err) == define.ErrDetach {
// User manually detached // User manually detached
// Exit cleanly immediately // Exit cleanly immediately
exitCode = 0 exitCode = 0
@ -626,7 +633,7 @@ func (r *LocalRuntime) Start(ctx context.Context, c *cliconfig.StartValues, sigP
} }
if ecode, err := ctr.Wait(); err != nil { if ecode, err := ctr.Wait(); err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
// The container may have been removed // The container may have been removed
// Go looking for an exit file // Go looking for an exit file
rtc, err := r.GetConfig() rtc, err := r.GetConfig()

11
pkg/adapter/containers_remote.go
View File

@ -16,6 +16,7 @@ import (
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
iopodman "github.com/containers/libpod/cmd/podman/varlink" iopodman "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/varlinkapi/virtwriter" "github.com/containers/libpod/pkg/varlinkapi/virtwriter"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
"github.com/docker/docker/pkg/term" "github.com/docker/docker/pkg/term"
@ -239,11 +240,11 @@ func (r *LocalRuntime) StopContainers(ctx context.Context, cli *cliconfig.StopVa
for _, id := range ids { for _, id := range ids {
if _, err := iopodman.StopContainer().Call(r.Conn, id, int64(cli.Timeout)); err != nil { if _, err := iopodman.StopContainer().Call(r.Conn, id, int64(cli.Timeout)); err != nil {
transError := TranslateError(err) transError := TranslateError(err)
if errors.Cause(transError) == libpod.ErrCtrStopped { if errors.Cause(transError) == define.ErrCtrStopped {
ok = append(ok, id) ok = append(ok, id)
continue continue
} }
if errors.Cause(transError) == libpod.ErrCtrStateInvalid && cli.All { if errors.Cause(transError) == define.ErrCtrStateInvalid && cli.All {
ok = append(ok, id) ok = append(ok, id)
continue continue
} }
@ -476,7 +477,7 @@ func (r *LocalRuntime) Run(ctx context.Context, c *cliconfig.RunValues, exitCode
} }
func ReadExitFile(runtimeTmp, ctrID string) (int, error) { func ReadExitFile(runtimeTmp, ctrID string) (int, error) {
return 0, libpod.ErrNotImplemented return 0, define.ErrNotImplemented
} }
// Ps lists containers based on criteria from user // Ps lists containers based on criteria from user
@ -662,7 +663,7 @@ func (r *LocalRuntime) Attach(ctx context.Context, c *cliconfig.AttachValues) er
} }
// Checkpoint one or more containers // Checkpoint one or more containers
func (r *LocalRuntime) Checkpoint(c *cliconfig.CheckpointValues, options libpod.ContainerCheckpointOptions) error { func (r *LocalRuntime) Checkpoint(c *cliconfig.CheckpointValues) error {
if c.Export != "" { if c.Export != "" {
return errors.New("the remote client does not support exporting checkpoints") return errors.New("the remote client does not support exporting checkpoints")
} }
@ -689,7 +690,7 @@ func (r *LocalRuntime) Checkpoint(c *cliconfig.CheckpointValues, options libpod.
} }
for _, id := range ids { for _, id := range ids {
if _, err := iopodman.ContainerCheckpoint().Call(r.Conn, id, options.Keep, options.KeepRunning, options.TCPEstablished); err != nil { if _, err := iopodman.ContainerCheckpoint().Call(r.Conn, id, c.Keep, c.Keep, c.TcpEstablished); err != nil {
if lastError != nil { if lastError != nil {
fmt.Fprintln(os.Stderr, lastError) fmt.Fprintln(os.Stderr, lastError)
} }

8
pkg/adapter/errors.go
View File

@ -4,7 +4,7 @@ package adapter
import ( import (
iopodman "github.com/containers/libpod/cmd/podman/varlink" iopodman "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod/define"
"github.com/pkg/errors" "github.com/pkg/errors"
) )
@ -21,11 +21,11 @@ func TranslateMapErrors(failures map[string]error) map[string]error {
func TranslateError(err error) error { func TranslateError(err error) error {
switch err.(type) { switch err.(type) {
case *iopodman.ContainerNotFound: case *iopodman.ContainerNotFound:
return errors.Wrap(libpod.ErrNoSuchCtr, err.Error()) return errors.Wrap(define.ErrNoSuchCtr, err.Error())
case *iopodman.ErrCtrStopped: case *iopodman.ErrCtrStopped:
return errors.Wrap(libpod.ErrCtrStopped, err.Error()) return errors.Wrap(define.ErrCtrStopped, err.Error())
case *iopodman.InvalidState: case *iopodman.InvalidState:
return errors.Wrap(libpod.ErrCtrStateInvalid, err.Error()) return errors.Wrap(define.ErrCtrStateInvalid, err.Error())
} }
return err return err
} }

3
pkg/adapter/pods_remote.go
View File

@ -12,6 +12,7 @@ import (
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/cmd/podman/varlink" "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/varlinkapi" "github.com/containers/libpod/pkg/varlinkapi"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -509,7 +510,7 @@ func (p *Pod) GetPodStats(previousContainerStats map[string]*libpod.ContainerSta
newStats := varlinkapi.ContainerStatsToLibpodContainerStats(stats) newStats := varlinkapi.ContainerStatsToLibpodContainerStats(stats)
// If the container wasn't running, don't include it // If the container wasn't running, don't include it
// but also suppress the error // but also suppress the error
if err != nil && errors.Cause(err) != libpod.ErrCtrStateInvalid { if err != nil && errors.Cause(err) != define.ErrCtrStateInvalid {
return nil, err return nil, err
} }
if err == nil { if err == nil {

11
pkg/adapter/runtime_remote.go
View File

@ -23,6 +23,7 @@ import (
"github.com/containers/libpod/cmd/podman/remoteclientconfig" "github.com/containers/libpod/cmd/podman/remoteclientconfig"
"github.com/containers/libpod/cmd/podman/varlink" "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events" "github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/utils" "github.com/containers/libpod/utils"
@ -527,12 +528,12 @@ func (r *LocalRuntime) SendFileOverVarlink(source string) (string, error) {
// GetAllVolumes retrieves all the volumes // GetAllVolumes retrieves all the volumes
func (r *LocalRuntime) GetAllVolumes() ([]*libpod.Volume, error) { func (r *LocalRuntime) GetAllVolumes() ([]*libpod.Volume, error) {
return nil, libpod.ErrNotImplemented return nil, define.ErrNotImplemented
} }
// RemoveVolume removes a volumes // RemoveVolume removes a volumes
func (r *LocalRuntime) RemoveVolume(ctx context.Context, v *libpod.Volume, force, prune bool) error { func (r *LocalRuntime) RemoveVolume(ctx context.Context, v *libpod.Volume, force, prune bool) error {
return libpod.ErrNotImplemented return define.ErrNotImplemented
} }
// GetContainers retrieves all containers from the state // GetContainers retrieves all containers from the state
@ -540,14 +541,14 @@ func (r *LocalRuntime) RemoveVolume(ctx context.Context, v *libpod.Volume, force
// the output. Multiple filters are handled by ANDing their output, so only // the output. Multiple filters are handled by ANDing their output, so only
// containers matching all filters are returned // containers matching all filters are returned
func (r *LocalRuntime) GetContainers(filters ...libpod.ContainerFilter) ([]*libpod.Container, error) { func (r *LocalRuntime) GetContainers(filters ...libpod.ContainerFilter) ([]*libpod.Container, error) {
return nil, libpod.ErrNotImplemented return nil, define.ErrNotImplemented
} }
// RemoveContainer removes the given container // RemoveContainer removes the given container
// If force is specified, the container will be stopped first // If force is specified, the container will be stopped first
// Otherwise, RemoveContainer will return an error if the container is running // Otherwise, RemoveContainer will return an error if the container is running
func (r *LocalRuntime) RemoveContainer(ctx context.Context, c *libpod.Container, force, volumes bool) error { func (r *LocalRuntime) RemoveContainer(ctx context.Context, c *libpod.Container, force, volumes bool) error {
return libpod.ErrNotImplemented return define.ErrNotImplemented
} }
// CreateVolume creates a volume over a varlink connection for the remote client // CreateVolume creates a volume over a varlink connection for the remote client
@ -771,7 +772,7 @@ func IsImageNotFound(err error) bool {
// HealthCheck executes a container's healthcheck over a varlink connection // HealthCheck executes a container's healthcheck over a varlink connection
func (r *LocalRuntime) HealthCheck(c *cliconfig.HealthCheckValues) (libpod.HealthCheckStatus, error) { func (r *LocalRuntime) HealthCheck(c *cliconfig.HealthCheckValues) (libpod.HealthCheckStatus, error) {
return -1, libpod.ErrNotImplemented return -1, define.ErrNotImplemented
} }
// Events monitors libpod/podman events over a varlink connection // Events monitors libpod/podman events over a varlink connection

5
pkg/spec/containerconfig.go
View File

@ -2,6 +2,7 @@ package createconfig
import ( import (
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
spec "github.com/opencontainers/runtime-spec/specs-go" spec "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -11,9 +12,9 @@ import (
// container with libpod from a completed CreateConfig struct. // container with libpod from a completed CreateConfig struct.
func (config *CreateConfig) MakeContainerConfig(runtime *libpod.Runtime, pod *libpod.Pod) (*spec.Spec, []libpod.CtrCreateOption, error) { func (config *CreateConfig) MakeContainerConfig(runtime *libpod.Runtime, pod *libpod.Pod) (*spec.Spec, []libpod.CtrCreateOption, error) {
if config.Pod != "" && pod == nil { if config.Pod != "" && pod == nil {
return nil, nil, errors.Wrapf(libpod.ErrInvalidArg, "pod was specified but no pod passed") return nil, nil, errors.Wrapf(define.ErrInvalidArg, "pod was specified but no pod passed")
} else if config.Pod == "" && pod != nil { } else if config.Pod == "" && pod != nil {
return nil, nil, errors.Wrapf(libpod.ErrInvalidArg, "pod was given but no pod is specified") return nil, nil, errors.Wrapf(define.ErrInvalidArg, "pod was given but no pod is specified")
} }
// Parse volumes flag into OCI spec mounts and libpod Named Volumes. // Parse volumes flag into OCI spec mounts and libpod Named Volumes.

9
pkg/spec/createconfig.go
View File

@ -9,6 +9,7 @@ import (
"github.com/containers/image/manifest" "github.com/containers/image/manifest"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/namespaces" "github.com/containers/libpod/pkg/namespaces"
"github.com/containers/storage" "github.com/containers/storage"
"github.com/cri-o/ocicni/pkg/ocicni" "github.com/cri-o/ocicni/pkg/ocicni"
@ -331,9 +332,9 @@ func (c *CreateConfig) getContainerCreateOptions(runtime *libpod.Runtime, pod *l
if c.IPAddress != "" { if c.IPAddress != "" {
ip := net.ParseIP(c.IPAddress) ip := net.ParseIP(c.IPAddress)
if ip == nil { if ip == nil {
return nil, errors.Wrapf(libpod.ErrInvalidArg, "cannot parse %s as IP address", c.IPAddress) return nil, errors.Wrapf(define.ErrInvalidArg, "cannot parse %s as IP address", c.IPAddress)
} else if ip.To4() == nil { } else if ip.To4() == nil {
return nil, errors.Wrapf(libpod.ErrInvalidArg, "%s is not an IPv4 address", c.IPAddress) return nil, errors.Wrapf(define.ErrInvalidArg, "%s is not an IPv4 address", c.IPAddress)
} }
options = append(options, libpod.WithStaticIP(ip)) options = append(options, libpod.WithStaticIP(ip))
} }
@ -371,7 +372,7 @@ func (c *CreateConfig) getContainerCreateOptions(runtime *libpod.Runtime, pod *l
if c.RestartPolicy != "" { if c.RestartPolicy != "" {
if c.RestartPolicy == "unless-stopped" { if c.RestartPolicy == "unless-stopped" {
return nil, errors.Wrapf(libpod.ErrInvalidArg, "the unless-stopped restart policy is not supported") return nil, errors.Wrapf(define.ErrInvalidArg, "the unless-stopped restart policy is not supported")
} }
split := strings.Split(c.RestartPolicy, ":") split := strings.Split(c.RestartPolicy, ":")
@ -381,7 +382,7 @@ func (c *CreateConfig) getContainerCreateOptions(runtime *libpod.Runtime, pod *l
return nil, errors.Wrapf(err, "%s is not a valid number of retries for restart policy", split[1]) return nil, errors.Wrapf(err, "%s is not a valid number of retries for restart policy", split[1])
} }
if numTries < 0 { if numTries < 0 {
return nil, errors.Wrapf(libpod.ErrInvalidArg, "restart policy requires a positive number of retries") return nil, errors.Wrapf(define.ErrInvalidArg, "restart policy requires a positive number of retries")
} }
options = append(options, libpod.WithRestartRetries(uint(numTries))) options = append(options, libpod.WithRestartRetries(uint(numTries)))
} }

3
pkg/varlinkapi/attach.go
View File

@ -8,6 +8,7 @@ import (
"github.com/containers/libpod/cmd/podman/varlink" "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/varlinkapi/virtwriter" "github.com/containers/libpod/pkg/varlinkapi/virtwriter"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
"k8s.io/client-go/tools/remotecommand" "k8s.io/client-go/tools/remotecommand"
@ -78,7 +79,7 @@ func (i *LibpodAPI) Attach(call iopodman.VarlinkCall, name string, detachKeys st
finalErr = startAndAttach(ctr, streams, detachKeys, resize, errChan) finalErr = startAndAttach(ctr, streams, detachKeys, resize, errChan)
} }
if finalErr != libpod.ErrDetach && finalErr != nil { if finalErr != define.ErrDetach && finalErr != nil {
logrus.Error(finalErr) logrus.Error(finalErr)
} }
quitWriter := virtwriter.NewVirtWriteCloser(writer, virtwriter.Quit) quitWriter := virtwriter.NewVirtWriteCloser(writer, virtwriter.Quit)

13
pkg/varlinkapi/containers.go
View File

@ -16,6 +16,7 @@ import (
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/cmd/podman/varlink" "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/pkg/adapter/shortcuts" "github.com/containers/libpod/pkg/adapter/shortcuts"
cc "github.com/containers/libpod/pkg/spec" cc "github.com/containers/libpod/pkg/spec"
"github.com/containers/storage/pkg/archive" "github.com/containers/storage/pkg/archive"
@ -119,7 +120,7 @@ func (i *LibpodAPI) GetContainersByContext(call iopodman.VarlinkCall, all, lates
ctrs, err := shortcuts.GetContainersByContext(all, latest, input, i.Runtime) ctrs, err := shortcuts.GetContainersByContext(all, latest, input, i.Runtime)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
return call.ReplyContainerNotFound("", err.Error()) return call.ReplyContainerNotFound("", err.Error())
} }
return call.ReplyErrorOccurred(err.Error()) return call.ReplyErrorOccurred(err.Error())
@ -326,7 +327,7 @@ func (i *LibpodAPI) GetContainerStats(call iopodman.VarlinkCall, name string) er
} }
containerStats, err := ctr.GetContainerStats(&libpod.ContainerStats{}) containerStats, err := ctr.GetContainerStats(&libpod.ContainerStats{})
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrCtrStateInvalid { if errors.Cause(err) == define.ErrCtrStateInvalid {
return call.ReplyNoContainerRunning() return call.ReplyNoContainerRunning()
} }
return call.ReplyErrorOccurred(err.Error()) return call.ReplyErrorOccurred(err.Error())
@ -379,7 +380,7 @@ func (i *LibpodAPI) InitContainer(call iopodman.VarlinkCall, name string) error
return call.ReplyContainerNotFound(name, err.Error()) return call.ReplyContainerNotFound(name, err.Error())
} }
if err := ctr.Init(getContext()); err != nil { if err := ctr.Init(getContext()); err != nil {
if errors.Cause(err) == libpod.ErrCtrStateInvalid { if errors.Cause(err) == define.ErrCtrStateInvalid {
return call.ReplyInvalidState(ctr.ID(), err.Error()) return call.ReplyInvalidState(ctr.ID(), err.Error())
} }
return call.ReplyErrorOccurred(err.Error()) return call.ReplyErrorOccurred(err.Error())
@ -394,10 +395,10 @@ func (i *LibpodAPI) StopContainer(call iopodman.VarlinkCall, name string, timeou
return call.ReplyContainerNotFound(name, err.Error()) return call.ReplyContainerNotFound(name, err.Error())
} }
if err := ctr.StopWithTimeout(uint(timeout)); err != nil { if err := ctr.StopWithTimeout(uint(timeout)); err != nil {
if errors.Cause(err) == libpod.ErrCtrStopped { if errors.Cause(err) == define.ErrCtrStopped {
return call.ReplyErrCtrStopped(ctr.ID()) return call.ReplyErrCtrStopped(ctr.ID())
} }
if errors.Cause(err) == libpod.ErrCtrStateInvalid { if errors.Cause(err) == define.ErrCtrStateInvalid {
return call.ReplyInvalidState(ctr.ID(), err.Error()) return call.ReplyInvalidState(ctr.ID(), err.Error())
} }
return call.ReplyErrorOccurred(err.Error()) return call.ReplyErrorOccurred(err.Error())
@ -420,7 +421,7 @@ func (i *LibpodAPI) RestartContainer(call iopodman.VarlinkCall, name string, tim
// ContainerExists looks in local storage for the existence of a container // ContainerExists looks in local storage for the existence of a container
func (i *LibpodAPI) ContainerExists(call iopodman.VarlinkCall, name string) error { func (i *LibpodAPI) ContainerExists(call iopodman.VarlinkCall, name string) error {
_, err := i.Runtime.LookupContainer(name) _, err := i.Runtime.LookupContainer(name)
if errors.Cause(err) == libpod.ErrNoSuchCtr { if errors.Cause(err) == define.ErrNoSuchCtr {
return call.ReplyContainerExists(1) return call.ReplyContainerExists(1)
} }
if err != nil { if err != nil {

3
pkg/varlinkapi/images.go
View File

@ -23,6 +23,7 @@ import (
"github.com/containers/libpod/cmd/podman/shared" "github.com/containers/libpod/cmd/podman/shared"
"github.com/containers/libpod/cmd/podman/varlink" "github.com/containers/libpod/cmd/podman/varlink"
"github.com/containers/libpod/libpod" "github.com/containers/libpod/libpod"
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/image" "github.com/containers/libpod/libpod/image"
"github.com/containers/libpod/pkg/util" "github.com/containers/libpod/pkg/util"
"github.com/containers/libpod/utils" "github.com/containers/libpod/utils"
@ -760,7 +761,7 @@ func (i *LibpodAPI) ImagesPrune(call iopodman.VarlinkCall, all bool) error {
func (i *LibpodAPI) ImageSave(call iopodman.VarlinkCall, options iopodman.ImageSaveOptions) error { func (i *LibpodAPI) ImageSave(call iopodman.VarlinkCall, options iopodman.ImageSaveOptions) error {
newImage, err := i.Runtime.ImageRuntime().NewFromLocal(options.Name) newImage, err := i.Runtime.ImageRuntime().NewFromLocal(options.Name)
if err != nil { if err != nil {
if errors.Cause(err) == libpod.ErrNoSuchImage { if errors.Cause(err) == define.ErrNoSuchImage {
return call.ReplyImageNotFound(options.Name, err.Error()) return call.ReplyImageNotFound(options.Name, err.Error())
} }
return call.ReplyErrorOccurred(err.Error()) return call.ReplyErrorOccurred(err.Error())