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

kpod ps 

Wire up kpod ps with the new libpod container backend.

Signed-off-by: baude <bbaude@redhat.com>

Closes: #67
Approved by: rhatdan
This commit is contained in:
baude 2017-11-21 14:12:21 -06:00 committed by Atomic Bot
parent 7eb4772694
commit 342ce4db50
3 changed files with 316 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
cmd/kpod/ps.go
View File

@ -15,9 +15,11 @@ import (
"k8s.io/apimachinery/pkg/fields"
"fmt"
"github.com/pkg/errors"
"github.com/projectatomic/libpod/cmd/kpod/formats"
"github.com/projectatomic/libpod/libkpod"
"github.com/projectatomic/libpod/libpod"
"github.com/projectatomic/libpod/oci"
"github.com/urfave/cli"
)
@ -144,18 +146,19 @@ func psCmd(c *cli.Context) error {
if err := validateFlags(c, psFlags); err != nil {
return err
}
config, err := getConfig(c)
// latest, and last are mutually exclusive.
if c.Int("last") >= 0 && c.Bool("latest") {
return errors.Errorf("last and latest are mutually exclusive")
}
runtime, err := getRuntime(c)
if err != nil {
return errors.Wrapf(err, "could not get config")
}
server, err := libkpod.New(config)
if err != nil {
return errors.Wrapf(err, "error creating server")
}
if err := server.Update(); err != nil {
return errors.Wrapf(err, "error updating list of containers")
return errors.Wrapf(err, "error creating libpod runtime")
}
defer runtime.Shutdown(false)
if len(c.Args()) > 0 {
return errors.Errorf("too many arguments, ps takes no arguments")
}
@ -177,38 +180,128 @@ func psCmd(c *cli.Context) error {
namespace: c.Bool("namespace"),
}
// all, latest, and last are mutually exclusive. Only one flag can be used at a time
exclusiveOpts := 0
if opts.last >= 0 {
exclusiveOpts++
}
if opts.latest {
exclusiveOpts++
}
if opts.all {
exclusiveOpts++
}
if exclusiveOpts > 1 {
return errors.Errorf("Last, latest and all are mutually exclusive")
var filterFuncs []libpod.ContainerFilter
// When we are dealing with latest or last=n, we need to
// get all containers.
if !opts.all && !opts.latest && opts.last < 1 {
// only get running containers
filterFuncs = append(filterFuncs, func(c *libpod.Container) bool {
state, _ := c.State()
return state == libpod.ContainerStateRunning
})
}
containers, err := server.ListContainers()
if err != nil {
return errors.Wrapf(err, "error getting containers from server")
}
var params *FilterParamsPS
if opts.filter != "" {
params, err = parseFilter(opts.filter, containers)
filters := strings.Split(opts.filter, ",")
for _, f := range filters {
filterSplit := strings.Split(f, "=")
if len(filterSplit) < 2 {
return errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
}
generatedFunc, err := generateContainerFilterFuncs(filterSplit[0], filterSplit[1], runtime)
if err != nil {
return errors.Wrapf(err, "error parsing filter")
return errors.Wrapf(err, "invalid filter")
}
filterFuncs = append(filterFuncs, generatedFunc)
}
}
containers, err := runtime.GetContainers(filterFuncs...)
var outputContainers []*libpod.Container
if opts.latest && len(containers) > 0 {
outputContainers = append(outputContainers, containers[0])
} else if opts.last > 0 && opts.last <= len(containers) {
outputContainers = append(outputContainers, containers[:opts.last]...)
} else {
params = nil
outputContainers = containers
}
containerList := getContainersMatchingFilter(containers, params, server)
return generatePsOutput(outputContainers, opts)
}
return generatePsOutput(containerList, server, opts)
func generateContainerFilterFuncs(filter, filterValue string, runtime *libpod.Runtime) (func(container *libpod.Container) bool, error) {
switch filter {
case "id":
return func(c *libpod.Container) bool {
return c.ID() == filterValue
}, nil
case "label":
return func(c *libpod.Container) bool {
for _, label := range c.Labels() {
if label == filterValue {
return true
}
}
return false
}, nil
case "name":
return func(c *libpod.Container) bool {
return c.Name() == filterValue
}, nil
case "exited":
exitCode, err := strconv.ParseInt(filterValue, 10, 32)
if err != nil {
return nil, errors.Wrapf(err, "exited code out of range %q", filterValue)
}
return func(c *libpod.Container) bool {
ec, err := c.ExitCode()
if ec == int32(exitCode) && err == nil {
return true
}
return false
}, nil
case "status":
if !libpod.StringInSlice(filterValue, []string{"created", "restarting", "running", "paused", "exited", "unknown"}) {
return nil, errors.Errorf("%s is not a valid status", filterValue)
}
return func(c *libpod.Container) bool {
status, err := c.State()
if err != nil {
return false
}
return status.String() == filterValue
}, nil
case "ancestor":
// This needs to refine to match docker
// - ancestor=(<image-name>[:tag]|<image-id>| ⟨image@digest⟩) - containers created from an image or a descendant.
return func(c *libpod.Container) bool {
containerConfig := c.Config()
if containerConfig.RootfsImageID == filterValue || containerConfig.RootfsImageName == filterValue {
return true
}
return false
}, nil
case "before":
ctr, err := runtime.LookupContainer(filterValue)
if err != nil {
return nil, errors.Errorf("unable to find container by name or id of %s", filterValue)
}
containerConfig := ctr.Config()
createTime := containerConfig.CreatedTime
return func(c *libpod.Container) bool {
cc := c.Config()
return createTime.After(cc.CreatedTime)
}, nil
case "since":
ctr, err := runtime.LookupContainer(filterValue)
if err != nil {
return nil, errors.Errorf("unable to find container by name or id of %s", filterValue)
}
containerConfig := ctr.Config()
createTime := containerConfig.CreatedTime
return func(c *libpod.Container) bool {
cc := c.Config()
return createTime.Before(cc.CreatedTime)
}, nil
case "volume":
//- volume=(<volume-name>|<mount-point-destination>)
return func(c *libpod.Container) bool {
containerConfig := c.Config()
//TODO We need to still lookup against volumes too
return containerConfig.MountLabel == filterValue
}, nil
}
return nil, errors.Errorf("%s is an invalid filter", filter)
}
// generate the template based on conditions given
@ -280,37 +373,60 @@ func getContainers(containers []*libkpod.ContainerData, opts psOptions) []*libkp
}
// getTemplateOutput returns the modified container information
func getTemplateOutput(containers []*libkpod.ContainerData, opts psOptions) (psOutput []psTemplateParams) {
func getTemplateOutput(containers []*libpod.Container, opts psOptions) ([]psTemplateParams, error) {
var psOutput []psTemplateParams
var status string
for _, ctr := range containers {
ctrID := ctr.ID
runningFor := units.HumanDuration(time.Since(ctr.State.Created))
ctrID := ctr.ID()
conConfig := ctr.Config()
conState, err := ctr.State()
if err != nil {
return psOutput, errors.Wrapf(err, "unable to obtain container state")
}
exitCode, err := ctr.ExitCode()
if err != nil {
return psOutput, errors.Wrapf(err, "unable to obtain container exit code")
}
pid, err := ctr.PID()
if err != nil {
return psOutput, errors.Wrapf(err, "unable to obtain container pid")
}
runningFor := units.HumanDuration(time.Since(conConfig.CreatedTime))
createdAt := runningFor + " ago"
command := getStrFromSquareBrackets(ctr.ImageCreatedBy)
imageName := ctr.FromImage
mounts := getMounts(ctr.Mounts, opts.noTrunc)
ports := getPorts(ctr.Config.ExposedPorts)
size := units.HumanSize(float64(ctr.SizeRootFs))
labels := getLabels(ctr.Labels)
imageName := conConfig.RootfsImageName
ns := getNamespaces(ctr.State.Pid)
// TODO We currently dont have the ability to get many of
// these data items. Uncomment as progress is made
switch ctr.State.Status {
case oci.ContainerStateStopped:
status = "Exited (" + strconv.FormatInt(int64(ctr.State.ExitCode), 10) + ") " + runningFor + " ago"
case oci.ContainerStateRunning:
//command := getStrFromSquareBrackets(ctr.ImageCreatedBy)
command := strings.Join(ctr.Spec().Process.Args, " ")
//mounts := getMounts(ctr.Mounts, opts.noTrunc)
//ports := getPorts(ctr.Config.ExposedPorts)
//size := units.HumanSize(float64(ctr.SizeRootFs))
labels := formatLabels(ctr.Labels())
ns := getNamespaces(pid)
switch conState {
case libpod.ContainerStateStopped:
status = fmt.Sprintf("Exited (%d) %s ago", exitCode, runningFor)
case libpod.ContainerStateRunning:
status = "Up " + runningFor + " ago"
case oci.ContainerStatePaused:
case libpod.ContainerStatePaused:
status = "Paused"
default:
case libpod.ContainerStateCreated:
status = "Created"
default:
status = "Dead"
}
if !opts.noTrunc {
ctrID = ctr.ID[:idTruncLength]
imageName = getImageName(ctr.FromImage)
ctrID = ctr.ID()[:idTruncLength]
imageName = conConfig.RootfsImageName
}
// TODO We currently dont have the ability to get many of
// these data items. Uncomment as progress is made
params := psTemplateParams{
ID: ctrID,
Image: imageName,
@ -318,12 +434,12 @@ func getTemplateOutput(containers []*libkpod.ContainerData, opts psOptions) (psO
CreatedAt: createdAt,
RunningFor: runningFor,
Status: status,
Ports: ports,
Size: size,
Names: ctr.Name,
//Ports: ports,
//Size: size,
Names: ctr.Name(),
Labels: labels,
Mounts: mounts,
PID: ctr.State.Pid,
//Mounts: mounts,
PID: pid,
Cgroup: ns.Cgroup,
IPC: ns.IPC,
MNT: ns.MNT,
@ -334,7 +450,7 @@ func getTemplateOutput(containers []*libkpod.ContainerData, opts psOptions) (psO
}
psOutput = append(psOutput, params)
}
return
return psOutput, nil
}
func getNamespaces(pid int) *namespace {
@ -368,50 +484,64 @@ func getNamespaceInfo(path string) (string, error) {
}
// getJSONOutput returns the container info in its raw form
func getJSONOutput(containers []*libkpod.ContainerData, nSpace bool) (psOutput []psJSONParams) {
func getJSONOutput(containers []*libpod.Container, nSpace bool) ([]psJSONParams, error) {
var psOutput []psJSONParams
var ns *namespace
for _, ctr := range containers {
if nSpace {
ns = getNamespaces(ctr.State.Pid)
pid, err := ctr.PID()
if err != nil {
return psOutput, errors.Wrapf(err, "unable to obtain container pid")
}
if nSpace {
ns = getNamespaces(pid)
}
cc := ctr.Config()
conState, err := ctr.State()
if err != nil {
return psOutput, errors.Wrapf(err, "unable to obtain container state for JSON output")
}
params := psJSONParams{
ID: ctr.ID,
Image: ctr.FromImage,
ImageID: ctr.FromImageID,
Command: getStrFromSquareBrackets(ctr.ImageCreatedBy),
CreatedAt: ctr.State.Created,
RunningFor: time.Since(ctr.State.Created),
Status: ctr.State.Status,
Ports: ctr.Config.ExposedPorts,
Size: ctr.SizeRootFs,
Names: ctr.Name,
Labels: ctr.Labels,
Mounts: ctr.Mounts,
ContainerRunning: ctr.State.Status == oci.ContainerStateRunning,
// TODO When we have ability to obtain the commented out data, we need
// TODO to add it
ID: ctr.ID(),
Image: cc.RootfsImageName,
ImageID: cc.RootfsImageID,
//Command: getStrFromSquareBrackets(ctr.ImageCreatedBy),
Command: strings.Join(ctr.Spec().Process.Args, " "),
CreatedAt: cc.CreatedTime,
RunningFor: time.Since(cc.CreatedTime),
Status: conState.String(),
//Ports: cc.Spec.Linux.Resources.Network.
//Size: ctr.SizeRootFs,
Names: cc.Name,
Labels: cc.Labels,
Mounts: cc.Spec.Mounts,
ContainerRunning: conState.String() == oci.ContainerStateRunning,
Namespaces: ns,
}
psOutput = append(psOutput, params)
}
return
return psOutput, nil
}
func generatePsOutput(containers []*libkpod.ContainerData, server *libkpod.ContainerServer, opts psOptions) error {
containersOutput := getContainers(containers, opts)
// In the case of JSON, we want to continue so we at least pass
// {} --valid JSON-- to the consumer
if len(containersOutput) == 0 && opts.format != formats.JSONString {
func generatePsOutput(containers []*libpod.Container, opts psOptions) error {
if len(containers) == 0 && opts.format != formats.JSONString {
return nil
}
var out formats.Writer
switch opts.format {
case formats.JSONString:
psOutput := getJSONOutput(containersOutput, opts.namespace)
psOutput, err := getJSONOutput(containers, opts.namespace)
if err != nil {
return errors.Wrapf(err, "unable to create JSON for output")
}
out = formats.JSONStructArray{Output: psToGeneric([]psTemplateParams{}, psOutput)}
default:
psOutput := getTemplateOutput(containersOutput, opts)
psOutput, err := getTemplateOutput(containers, opts)
if err != nil {
return errors.Wrapf(err, "unable to create output")
}
out = formats.StdoutTemplateArray{Output: psToGeneric(psOutput, []psJSONParams{}), Template: opts.format, Fields: psOutput[0].headerMap()}
}
@ -440,7 +570,7 @@ func getImageName(img string) string {
}
// getLabels converts the labels to a string of the form "key=value, key2=value2"
func getLabels(labels fields.Set) string {
func formatLabels(labels map[string]string) string {
var arr []string
if len(labels) > 0 {
for key, val := range labels {

79
libpod/container.go
View File

@ -124,6 +124,26 @@ type ContainerConfig struct {
// TODO allow overriding of log path
}
// ContainerStater returns a string representation for users
// of a container state
func (t ContainerState) String() string {
switch t {
case ContainerStateUnknown:
return "unknown"
case ContainerStateConfigured:
return "configured"
case ContainerStateCreated:
return "created"
case ContainerStateRunning:
return "running"
case ContainerStateStopped:
return "exited"
case ContainerStatePaused:
return "paused"
}
return ""
}
// ID returns the container's ID
func (c *Container) ID() string {
return c.config.ID
@ -170,6 +190,59 @@ func (c *Container) LogPath() string {
return c.logPath()
}
// ExitCode returns the exit code of the container as
// an int32
func (c *Container) ExitCode() (int32, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.syncContainer(); err != nil {
return 0, errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.ExitCode, nil
}
// Mounted returns a bool as to if the container's storage
// is mounted
func (c *Container) Mounted() (bool, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.syncContainer(); err != nil {
return false, errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.Mounted, nil
}
// Mountpoint returns the path to the container's mounted
// storage as a string
func (c *Container) Mountpoint() (string, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.syncContainer(); err != nil {
return "", errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.Mountpoint, nil
}
// StartedTime is the time the container was started
func (c *Container) StartedTime() (time.Time, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.syncContainer(); err != nil {
return time.Time{}, errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.StartedTime, nil
}
// FinishedTime is the time the container was stopped
func (c *Container) FinishedTime() (time.Time, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.syncContainer(); err != nil {
return time.Time{}, errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.FinishedTime, nil
}
// State returns the current state of the container
func (c *Container) State() (ContainerState, error) {
c.lock.Lock()
@ -178,7 +251,6 @@ func (c *Container) State() (ContainerState, error) {
if err := c.syncContainer(); err != nil {
return ContainerStateUnknown, err
}
return c.state.State, nil
}
@ -199,11 +271,9 @@ func (c *Container) PID() (int, error) {
func (c *Container) MountPoint() (string, error) {
c.lock.Lock()
defer c.lock.Unlock()
if err := c.runtime.state.UpdateContainer(c); err != nil {
if err := c.syncContainer(); err != nil {
return "", errors.Wrapf(err, "error updating container %s state", c.ID())
}
return c.state.Mountpoint, nil
}
@ -229,7 +299,6 @@ func (c *Container) syncContainer() error {
if err := c.runtime.state.UpdateContainer(c); err != nil {
return err
}
// If runc knows about the container, update its status in runc
// And then save back to disk
if (c.state.State != ContainerStateUnknown) &&

250
test/kpod_ps.bats
View File

@ -15,317 +15,105 @@ function setup() {
}
@test "kpod ps default" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
ctr_id="$output"
run crioctl ctr start --id "$ctr_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps all flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps --all
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps size flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a -s
echo "$output"
[ "$status" -eq 0 ]
skip "Need size flag implemented in container backend"
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --size
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps quiet flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a -q
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --quiet
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps latest flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps --latest
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -l
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps last flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${BB} ls
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls -s
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps --last 2
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -n 2
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps no-trunc flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --no-trunc
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps namespace flag" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --ns
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps --all --namespace
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps namespace flag and format flag = json" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c "${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --ns --format json | python -m json.tool | grep namespace"
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps without namespace flag and format flag = json" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c "${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --format json | python -m json.tool | grep namespace"
echo "$output"
[ "$status" -eq 1 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps format flag = go template" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --format "table {{.ID}} {{.Image}} {{.Labels}}"
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps filter flag - ancestor" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --filter ancestor=${ALPINE}
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --filter ancestor=${IMAGE}
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps filter flag - id" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run ${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} ls
ctr_id="$output"
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --filter id="$ctr_id"
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
}
@test "kpod ps filter flag - status" {
skip "Test needs to be converted to kpod run"
start_crio
run crioctl pod run --config "$TESTDATA"/sandbox_config.json
echo "$output"
[ "$status" -eq 0 ]
pod_id="$output"
run crioctl image pull "$IMAGE"
echo "$output"
[ "$status" -eq 0 ]
run crioctl ctr create --config "$TESTDATA"/container_config.json --pod "$pod_id"
echo "$output"
[ "$status" -eq 0 ]
run ${KPOD_BINARY} ${KPOD_OPTIONS} run -d ${ALPINE} sleep 99
ctr_id="$output"
run bash -c ${KPOD_BINARY} ${KPOD_OPTIONS} ps -a --filter status=running
echo "$output"
[ "$status" -eq 0 ]
cleanup_ctrs
cleanup_pods
stop_crio
run ${KPOD_BINARY} ${KPOD_OPTIONS} stop $ctr_id
}