600 lines
18 KiB
Go
600 lines
18 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/cri-o/ocicni/pkg/ocicni"
|
|
"github.com/docker/go-units"
|
|
specs "github.com/opencontainers/runtime-spec/specs-go"
|
|
"github.com/pkg/errors"
|
|
"github.com/projectatomic/libpod/cmd/podman/batchcontainer"
|
|
"github.com/projectatomic/libpod/cmd/podman/formats"
|
|
"github.com/projectatomic/libpod/cmd/podman/libpodruntime"
|
|
"github.com/projectatomic/libpod/libpod"
|
|
cc "github.com/projectatomic/libpod/pkg/spec"
|
|
"github.com/projectatomic/libpod/pkg/util"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/urfave/cli"
|
|
"k8s.io/apimachinery/pkg/fields"
|
|
)
|
|
|
|
const mountTruncLength = 12
|
|
|
|
type psTemplateParams struct {
|
|
ID string
|
|
Image string
|
|
Command string
|
|
CreatedAtTime time.Time
|
|
Created string
|
|
RunningFor string
|
|
Status string
|
|
Ports string
|
|
Size string
|
|
Names string
|
|
Labels string
|
|
Mounts string
|
|
PID int
|
|
Cgroup string
|
|
IPC string
|
|
MNT string
|
|
NET string
|
|
PIDNS string
|
|
User string
|
|
UTS string
|
|
}
|
|
|
|
// psJSONParams is only used when the JSON format is specified,
|
|
// and is better for data processing from JSON.
|
|
// psJSONParams will be populated by data from libpod.Container,
|
|
// the members of the struct are the sama data types as their sources.
|
|
type psJSONParams struct {
|
|
ID string `json:"id"`
|
|
Image string `json:"image"`
|
|
ImageID string `json:"image_id"`
|
|
Command []string `json:"command"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
RunningFor time.Duration `json:"runningFor"`
|
|
Status string `json:"status"`
|
|
Ports []ocicni.PortMapping `json:"ports"`
|
|
RootFsSize int64 `json:"rootFsSize"`
|
|
RWSize int64 `json:"rwSize"`
|
|
Names string `json:"names"`
|
|
Labels fields.Set `json:"labels"`
|
|
Mounts []specs.Mount `json:"mounts"`
|
|
ContainerRunning bool `json:"ctrRunning"`
|
|
Namespaces *batchcontainer.Namespace `json:"namespace,omitempty"`
|
|
}
|
|
|
|
// Type declaration and functions for sorting the PS output by time
|
|
type psSorted []psTemplateParams
|
|
|
|
func (a psSorted) Len() int { return len(a) }
|
|
func (a psSorted) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
func (a psSorted) Less(i, j int) bool { return a[i].CreatedAtTime.After(a[j].CreatedAtTime) }
|
|
|
|
var (
|
|
psFlags = []cli.Flag{
|
|
cli.BoolFlag{
|
|
Name: "all, a",
|
|
Usage: "Show all the containers, default is only running containers",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "filter, f",
|
|
Usage: "Filter output based on conditions given",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "format",
|
|
Usage: "Pretty-print containers to JSON or using a Go template",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "last, n",
|
|
Usage: "Print the n last created containers (all states)",
|
|
Value: -1,
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "latest, l",
|
|
Usage: "Show the latest container created (all states)",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "no-trunc",
|
|
Usage: "Display the extended information",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "quiet, q",
|
|
Usage: "Print the numeric IDs of the containers only",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "size, s",
|
|
Usage: "Display the total file sizes",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "namespace, ns",
|
|
Usage: "Display namespace information",
|
|
},
|
|
}
|
|
psDescription = "Prints out information about the containers"
|
|
psCommand = cli.Command{
|
|
Name: "ps",
|
|
Usage: "List containers",
|
|
Description: psDescription,
|
|
Flags: psFlags,
|
|
Action: psCmd,
|
|
ArgsUsage: "",
|
|
UseShortOptionHandling: true,
|
|
}
|
|
)
|
|
|
|
func psCmd(c *cli.Context) error {
|
|
if err := validateFlags(c, psFlags); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := checkFlagsPassed(c); err != nil {
|
|
return errors.Wrapf(err, "error with flags passed")
|
|
}
|
|
|
|
runtime, err := libpodruntime.GetRuntime(c)
|
|
if err != nil {
|
|
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")
|
|
}
|
|
|
|
format := genPsFormat(c.String("format"), c.Bool("quiet"), c.Bool("size"), c.Bool("namespace"))
|
|
|
|
opts := batchcontainer.PsOptions{
|
|
All: c.Bool("all"),
|
|
Filter: c.String("filter"),
|
|
Format: format,
|
|
Last: c.Int("last"),
|
|
Latest: c.Bool("latest"),
|
|
NoTrunc: c.Bool("no-trunc"),
|
|
Quiet: c.Bool("quiet"),
|
|
Size: c.Bool("size"),
|
|
Namespace: c.Bool("namespace"),
|
|
}
|
|
|
|
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
|
|
})
|
|
}
|
|
|
|
if opts.Filter != "" {
|
|
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, "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 {
|
|
outputContainers = containers
|
|
}
|
|
|
|
return generatePsOutput(outputContainers, opts)
|
|
}
|
|
|
|
// checkFlagsPassed checks if mutually exclusive flags are passed together
|
|
func checkFlagsPassed(c *cli.Context) error {
|
|
// latest, and last are mutually exclusive.
|
|
if c.Int("last") >= 0 && c.Bool("latest") {
|
|
return errors.Errorf("last and latest are mutually exclusive")
|
|
}
|
|
// quiet, size, namespace, and format with Go template are mutually exclusive
|
|
flags := 0
|
|
if c.Bool("quiet") {
|
|
flags++
|
|
}
|
|
if c.Bool("size") {
|
|
flags++
|
|
}
|
|
if c.Bool("namespace") {
|
|
flags++
|
|
}
|
|
if c.IsSet("format") && c.String("format") != formats.JSONString {
|
|
flags++
|
|
}
|
|
if flags > 1 {
|
|
return errors.Errorf("quiet, size, namespace, and format with Go template are mutually exclusive")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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 strings.Contains(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 strings.Contains(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 !util.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
|
|
}
|
|
state := status.String()
|
|
if status == libpod.ContainerStateConfigured {
|
|
state = "created"
|
|
}
|
|
return state == 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 strings.Contains(containerConfig.RootfsImageID, filterValue) || strings.Contains(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()
|
|
var dest string
|
|
arr := strings.Split(filterValue, ":")
|
|
source := arr[0]
|
|
if len(arr) == 2 {
|
|
dest = arr[1]
|
|
}
|
|
for _, mount := range containerConfig.Spec.Mounts {
|
|
if dest != "" && (mount.Source == source && mount.Destination == dest) {
|
|
return true
|
|
}
|
|
if dest == "" && mount.Source == source {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}, nil
|
|
}
|
|
return nil, errors.Errorf("%s is an invalid filter", filter)
|
|
}
|
|
|
|
// generate the template based on conditions given
|
|
func genPsFormat(format string, quiet, size, namespace bool) string {
|
|
if format != "" {
|
|
// "\t" from the command line is not being recognized as a tab
|
|
// replacing the string "\t" to a tab character if the user passes in "\t"
|
|
return strings.Replace(format, `\t`, "\t", -1)
|
|
}
|
|
if quiet {
|
|
return formats.IDString
|
|
}
|
|
if namespace {
|
|
return "table {{.ID}}\t{{.Names}}\t{{.PID}}\t{{.Cgroup}}\t{{.IPC}}\t{{.MNT}}\t{{.NET}}\t{{.PIDNS}}\t{{.User}}\t{{.UTS}}\t"
|
|
}
|
|
format = "table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.Created}}\t{{.Status}}\t{{.Ports}}\t{{.Names}}\t"
|
|
if size {
|
|
format += "{{.Size}}\t"
|
|
}
|
|
return format
|
|
}
|
|
|
|
func psToGeneric(templParams []psTemplateParams, JSONParams []psJSONParams) (genericParams []interface{}) {
|
|
if len(templParams) > 0 {
|
|
for _, v := range templParams {
|
|
genericParams = append(genericParams, interface{}(v))
|
|
}
|
|
return
|
|
}
|
|
for _, v := range JSONParams {
|
|
genericParams = append(genericParams, interface{}(v))
|
|
}
|
|
return
|
|
}
|
|
|
|
// generate the accurate header based on template given
|
|
func (p *psTemplateParams) headerMap() map[string]string {
|
|
v := reflect.Indirect(reflect.ValueOf(p))
|
|
values := make(map[string]string)
|
|
|
|
for i := 0; i < v.NumField(); i++ {
|
|
key := v.Type().Field(i).Name
|
|
value := key
|
|
if value == "ID" {
|
|
value = "Container" + value
|
|
}
|
|
values[key] = strings.ToUpper(splitCamelCase(value))
|
|
}
|
|
return values
|
|
}
|
|
|
|
// getTemplateOutput returns the modified container information
|
|
func getTemplateOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) (psSorted, error) {
|
|
var (
|
|
psOutput psSorted
|
|
status, size string
|
|
ns *batchcontainer.Namespace
|
|
)
|
|
|
|
for _, ctr := range containers {
|
|
batchInfo, err := batchcontainer.BatchContainerOp(ctr, opts)
|
|
if err != nil {
|
|
// If the error was ErrNoSuchCtr, it was probably
|
|
// removed sometime after we got the initial list.
|
|
// Just ignore it.
|
|
if errors.Cause(err) == libpod.ErrNoSuchCtr {
|
|
logrus.Debugf("Container %s removed before batch, ignoring in output", ctr.ID())
|
|
continue
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
ctrID := ctr.ID()
|
|
runningFor := ""
|
|
// If the container has not be started, the "zero" value of time is 0001-01-01 00:00:00 +0000 UTC
|
|
// which would make the time elapsed about a few hundred of years. So checking for the "zero" value of time.Time
|
|
if !batchInfo.StartedTime.IsZero() {
|
|
runningFor = units.HumanDuration(time.Since(batchInfo.StartedTime))
|
|
}
|
|
imageName := batchInfo.ConConfig.RootfsImageName
|
|
|
|
var createArtifact cc.CreateConfig
|
|
artifact, err := ctr.GetArtifact("create-config")
|
|
if err == nil {
|
|
if err := json.Unmarshal(artifact, &createArtifact); err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
logrus.Errorf("couldn't get some ps information, error getting artifact %q: %v", ctr.ID(), err)
|
|
}
|
|
if opts.Namespace {
|
|
ns = batchcontainer.GetNamespaces(batchInfo.Pid)
|
|
}
|
|
if opts.Size {
|
|
|
|
size = units.HumanSizeWithPrecision(float64(batchInfo.RwSize), 3) + " (virtual " + units.HumanSizeWithPrecision(float64(batchInfo.RootFsSize), 3) + ")"
|
|
}
|
|
|
|
command := strings.Join(batchInfo.ConConfig.Spec.Process.Args, " ")
|
|
if !opts.NoTrunc {
|
|
if len(command) > 20 {
|
|
command = command[:19] + "..."
|
|
}
|
|
}
|
|
ports := portsToString(batchInfo.ConConfig.PortMappings)
|
|
mounts := getMounts(createArtifact.Volumes, opts.NoTrunc)
|
|
labels := formatLabels(ctr.Labels())
|
|
|
|
switch batchInfo.ConState {
|
|
case libpod.ContainerStateStopped:
|
|
status = fmt.Sprintf("Exited (%d) %s ago", batchInfo.ExitCode, runningFor)
|
|
case libpod.ContainerStateRunning:
|
|
status = "Up " + runningFor + " ago"
|
|
case libpod.ContainerStatePaused:
|
|
status = "Paused"
|
|
case libpod.ContainerStateCreated, libpod.ContainerStateConfigured:
|
|
status = "Created"
|
|
default:
|
|
status = "Dead"
|
|
}
|
|
|
|
if !opts.NoTrunc {
|
|
ctrID = shortID(ctr.ID())
|
|
imageName = batchInfo.ConConfig.RootfsImageName
|
|
}
|
|
params := psTemplateParams{
|
|
ID: ctrID,
|
|
Image: imageName,
|
|
Command: command,
|
|
CreatedAtTime: batchInfo.ConConfig.CreatedTime,
|
|
Created: units.HumanDuration(time.Since(batchInfo.ConConfig.CreatedTime)) + " ago",
|
|
RunningFor: runningFor,
|
|
Status: status,
|
|
Ports: ports,
|
|
Size: size,
|
|
Names: ctr.Name(),
|
|
Labels: labels,
|
|
Mounts: mounts,
|
|
PID: batchInfo.Pid,
|
|
}
|
|
|
|
if opts.Namespace {
|
|
params.Cgroup = ns.Cgroup
|
|
params.IPC = ns.IPC
|
|
params.MNT = ns.MNT
|
|
params.NET = ns.NET
|
|
params.PIDNS = ns.PIDNS
|
|
params.User = ns.User
|
|
params.UTS = ns.UTS
|
|
}
|
|
psOutput = append(psOutput, params)
|
|
}
|
|
// Sort the ps entries by created time
|
|
sort.Sort(psSorted(psOutput))
|
|
|
|
return psOutput, nil
|
|
}
|
|
|
|
// getJSONOutput returns the container info in its raw form
|
|
func getJSONOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) ([]psJSONParams, error) {
|
|
var (
|
|
psOutput []psJSONParams
|
|
ns *batchcontainer.Namespace
|
|
)
|
|
for _, ctr := range containers {
|
|
batchInfo, err := batchcontainer.BatchContainerOp(ctr, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if opts.Namespace {
|
|
ns = batchcontainer.GetNamespaces(batchInfo.Pid)
|
|
}
|
|
params := psJSONParams{
|
|
ID: ctr.ID(),
|
|
Image: batchInfo.ConConfig.RootfsImageName,
|
|
ImageID: batchInfo.ConConfig.RootfsImageID,
|
|
Command: batchInfo.ConConfig.Spec.Process.Args,
|
|
CreatedAt: batchInfo.ConConfig.CreatedTime,
|
|
Status: batchInfo.ConState.String(),
|
|
Ports: batchInfo.ConConfig.PortMappings,
|
|
RootFsSize: batchInfo.RootFsSize,
|
|
RWSize: batchInfo.RwSize,
|
|
Names: batchInfo.ConConfig.Name,
|
|
Labels: batchInfo.ConConfig.Labels,
|
|
Mounts: batchInfo.ConConfig.Spec.Mounts,
|
|
ContainerRunning: batchInfo.ConState == libpod.ContainerStateRunning,
|
|
Namespaces: ns,
|
|
}
|
|
|
|
if !batchInfo.StartedTime.IsZero() {
|
|
params.RunningFor = time.Since(batchInfo.StartedTime)
|
|
}
|
|
|
|
psOutput = append(psOutput, params)
|
|
}
|
|
return psOutput, nil
|
|
}
|
|
|
|
func generatePsOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) error {
|
|
if len(containers) == 0 && opts.Format != formats.JSONString {
|
|
return nil
|
|
}
|
|
var out formats.Writer
|
|
|
|
switch opts.Format {
|
|
case formats.JSONString:
|
|
psOutput, err := getJSONOutput(containers, opts)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "unable to create JSON for output")
|
|
}
|
|
out = formats.JSONStructArray{Output: psToGeneric([]psTemplateParams{}, psOutput)}
|
|
default:
|
|
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()}
|
|
}
|
|
|
|
return formats.Writer(out).Out()
|
|
}
|
|
|
|
// getLabels converts the labels to a string of the form "key=value, key2=value2"
|
|
func formatLabels(labels map[string]string) string {
|
|
var arr []string
|
|
if len(labels) > 0 {
|
|
for key, val := range labels {
|
|
temp := key + "=" + val
|
|
arr = append(arr, temp)
|
|
}
|
|
return strings.Join(arr, ",")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// getMounts converts the volumes mounted to a string of the form "mount1, mount2"
|
|
// it truncates it if noTrunc is false
|
|
func getMounts(mounts []string, noTrunc bool) string {
|
|
var arr []string
|
|
if len(mounts) == 0 {
|
|
return ""
|
|
}
|
|
for _, mount := range mounts {
|
|
splitArr := strings.Split(mount, ":")
|
|
if len(splitArr[0]) > mountTruncLength && !noTrunc {
|
|
arr = append(arr, splitArr[0][:mountTruncLength]+"...")
|
|
continue
|
|
}
|
|
arr = append(arr, splitArr[0])
|
|
}
|
|
return strings.Join(arr, ",")
|
|
}
|
|
|
|
// portsToString converts the ports used to a string of the from "port1, port2"
|
|
func portsToString(ports []ocicni.PortMapping) string {
|
|
var portDisplay []string
|
|
if len(ports) == 0 {
|
|
return ""
|
|
}
|
|
for _, v := range ports {
|
|
hostIP := v.HostIP
|
|
if hostIP == "" {
|
|
hostIP = "0.0.0.0"
|
|
}
|
|
portDisplay = append(portDisplay, fmt.Sprintf("%s:%d->%d/%s", hostIP, v.HostPort, v.ContainerPort, v.Protocol))
|
|
}
|
|
return strings.Join(portDisplay, ", ")
|
|
}
|