podmanv2 pod ps

add the ability to list pods in podmanv2

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

cmd/podmanV2/pods/pod.go

@@ -1,6 +1,9 @@
 package pods
 
 import (
+	"strings"
+	"text/template"
+
 	"github.com/containers/libpod/cmd/podmanV2/registry"
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -18,6 +21,33 @@ var (
 	}
 )
 
+var podFuncMap = template.FuncMap{
+	"numCons": func(cons []*entities.ListPodContainer) int {
+		return len(cons)
+	},
+	"podcids": func(cons []*entities.ListPodContainer) string {
+		var ctrids []string
+		for _, c := range cons {
+			ctrids = append(ctrids, c.Id[:12])
+		}
+		return strings.Join(ctrids, ",")
+	},
+	"podconnames": func(cons []*entities.ListPodContainer) string {
+		var ctrNames []string
+		for _, c := range cons {
+			ctrNames = append(ctrNames, c.Names[:12])
+		}
+		return strings.Join(ctrNames, ",")
+	},
+	"podconstatuses": func(cons []*entities.ListPodContainer) string {
+		var statuses []string
+		for _, c := range cons {
+			statuses = append(statuses, c.Status)
+		}
+		return strings.Join(statuses, ",")
+	},
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},

cmd/podmanV2/pods/ps.go

@@ -1,8 +1,19 @@
 package pods
 
 import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+
 	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/cmd/podmanV2/report"
 	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -19,14 +30,137 @@ var (
 	}
 )
 
+var (
+	defaultHeaders string = "POD ID\tNAME\tSTATUS\tCREATED"
+	inputFilters   string
+	noTrunc        bool
+	psInput        entities.PodPSOptions
+)
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: psCmd,
 		Parent:  podCmd,
 	})
+	flags := psCmd.Flags()
+	flags.BoolVar(&psInput.CtrNames, "ctr-names", false, "Display the container names")
+	flags.BoolVar(&psInput.CtrIds, "ctr-ids", false, "Display the container UUIDs. If no-trunc is not set they will be truncated")
+	flags.BoolVar(&psInput.CtrStatus, "ctr-status", false, "Display the container status")
+	// TODO should we make this a [] ?
+	flags.StringVarP(&inputFilters, "filter", "f", "", "Filter output based on conditions given")
+	flags.StringVar(&psInput.Format, "format", "", "Pretty-print pods to JSON or using a Go template")
+	flags.BoolVarP(&psInput.Latest, "latest", "l", false, "Act on the latest pod podman is aware of")
+	flags.BoolVar(&psInput.Namespace, "namespace", false, "Display namespace information of the pod")
+	flags.BoolVar(&psInput.Namespace, "ns", false, "Display namespace information of the pod")
+	flags.BoolVar(&noTrunc, "no-trunc", false, "Do not truncate pod and container IDs")
+	flags.BoolVarP(&psInput.Quiet, "quiet", "q", false, "Print the numeric IDs of the pods only")
+	flags.StringVar(&psInput.Sort, "sort", "created", "Sort output by created, id, name, or number")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+	}
 }
 
 func pods(cmd *cobra.Command, args []string) error {
+	var (
+		w   io.Writer = os.Stdout
+		row string
+	)
+	if cmd.Flag("filter").Changed {
+		for _, f := range strings.Split(inputFilters, ",") {
+			split := strings.Split(f, "=")
+			if len(split) < 2 {
+				return errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
+			}
+			psInput.Filters[split[0]] = append(psInput.Filters[split[0]], split[1])
+		}
+	}
+	responses, err := registry.ContainerEngine().PodPs(context.Background(), psInput)
+	if err != nil {
+		return err
+	}
+
+	if psInput.Format == "json" {
+		b, err := json.MarshalIndent(responses, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(b))
+		return nil
+	}
+	headers, row := createPodPsOut(cmd)
+	if psInput.Quiet {
+		if noTrunc {
+			row = "{{.Id}}\n"
+		} else {
+			row = "{{slice .Id 0 12}}\n"
+		}
+	}
+	if cmd.Flag("format").Changed {
+		row = psInput.Format
+		if !strings.HasPrefix(row, "\n") {
+			row += "\n"
+		}
+	}
+	format := "{{range . }}" + row + "{{end}}"
+	if !psInput.Quiet && !cmd.Flag("format").Changed {
+		format = headers + format
+	}
+	funcs := report.AppendFuncMap(podFuncMap)
+	tmpl, err := template.New("listPods").Funcs(funcs).Parse(format)
+	if err != nil {
+		return err
+	}
+	if !psInput.Quiet {
+		w = tabwriter.NewWriter(os.Stdout, 8, 2, 2, ' ', 0)
+	}
+	if err := tmpl.Execute(w, responses); err != nil {
+		return err
+	}
+	if flusher, ok := w.(interface{ Flush() error }); ok {
+		return flusher.Flush()
+	}
 	return nil
 }
+
+func createPodPsOut(cmd *cobra.Command) (string, string) {
+	var row string
+	headers := defaultHeaders
+	if noTrunc {
+		row += "{{.Id}}"
+	} else {
+		row += "{{slice .Id 0 12}}"
+	}
+
+	row += "\t{{.Name}}\t{{.Status}}\t{{humanDurationFromTime .Created}}"
+
+	//rowFormat      string = "{{slice .Id 0 12}}\t{{.Name}}\t{{.Status}}\t{{humanDurationFromTime .Created}}"
+	if psInput.CtrIds {
+		headers += "\tIDS"
+		row += "\t{{podcids .Containers}}"
+	}
+	if psInput.CtrNames {
+		headers += "\tNAMES"
+		row += "\t{{podconnames .Containers}}"
+	}
+	if psInput.CtrStatus {
+		headers += "\tSTATUS"
+		row += "\t{{podconstatuses .Containers}}"
+	}
+	if psInput.Namespace {
+		headers += "\tCGROUP\tNAMESPACES"
+		row += "\t{{.Cgroup}}\t{{.Namespace}}"
+	}
+	if !psInput.CtrStatus && !psInput.CtrNames && !psInput.CtrIds {
+		headers += "\t# OF CONTAINERS"
+		row += "\t{{numCons .Containers}}"
+
+	}
+	headers += "\tINFRA ID\n"
+	if noTrunc {
+		row += "\t{{.InfraId}}\n"
+	} else {
+		row += "\t{{slice .InfraId 0 12}}\n"
+	}
+	return headers, row
+}

cmd/podmanV2/report/templates.go

@@ -19,6 +19,9 @@ var defaultFuncMap = template.FuncMap{
 	"humanDuration": func(t int64) string {
 		return units.HumanDuration(time.Since(time.Unix(t, 0))) + " ago"
 	},
+	"humanDurationFromTime": func(t time.Time) string {
+		return units.HumanDuration(time.Since(t)) + " ago"
+	},
 	"humanSize": func(sz int64) string {
 		s := units.HumanSizeWithPrecision(float64(sz), 3)
 		i := strings.LastIndexFunc(s, unicode.IsNumber)

libpod/podfilters/pods.go

@@ -0,0 +1,115 @@
+package podfilters
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/libpod/define"
+	"github.com/containers/libpod/pkg/util"
+	"github.com/pkg/errors"
+)
+
+// GeneratePodFilterFunc takes a filter and filtervalue (key, value)
+// and generates a libpod function that can be used to filter
+// pods
+func GeneratePodFilterFunc(filter, filterValue string) (
+	func(pod *libpod.Pod) bool, error) {
+	switch filter {
+	case "ctr-ids":
+		return func(p *libpod.Pod) bool {
+			ctrIds, err := p.AllContainersByID()
+			if err != nil {
+				return false
+			}
+			return util.StringInSlice(filterValue, ctrIds)
+		}, nil
+	case "ctr-names":
+		return func(p *libpod.Pod) bool {
+			ctrs, err := p.AllContainers()
+			if err != nil {
+				return false
+			}
+			for _, ctr := range ctrs {
+				if filterValue == ctr.Name() {
+					return true
+				}
+			}
+			return false
+		}, nil
+	case "ctr-number":
+		return func(p *libpod.Pod) bool {
+			ctrIds, err := p.AllContainersByID()
+			if err != nil {
+				return false
+			}
+
+			fVint, err2 := strconv.Atoi(filterValue)
+			if err2 != nil {
+				return false
+			}
+			return len(ctrIds) == fVint
+		}, nil
+	case "ctr-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(p *libpod.Pod) bool {
+			ctr_statuses, err := p.Status()
+			if err != nil {
+				return false
+			}
+			for _, ctr_status := range ctr_statuses {
+				state := ctr_status.String()
+				if ctr_status == define.ContainerStateConfigured {
+					state = "created"
+				}
+				if state == filterValue {
+					return true
+				}
+			}
+			return false
+		}, nil
+	case "id":
+		return func(p *libpod.Pod) bool {
+			return strings.Contains(p.ID(), filterValue)
+		}, nil
+	case "name":
+		return func(p *libpod.Pod) bool {
+			return strings.Contains(p.Name(), filterValue)
+		}, nil
+	case "status":
+		if !util.StringInSlice(filterValue, []string{"stopped", "running", "paused", "exited", "dead", "created"}) {
+			return nil, errors.Errorf("%s is not a valid pod status", filterValue)
+		}
+		return func(p *libpod.Pod) bool {
+			status, err := p.GetPodStatus()
+			if err != nil {
+				return false
+			}
+			if strings.ToLower(status) == filterValue {
+				return true
+			}
+			return false
+		}, nil
+	case "label":
+		var filterArray = strings.SplitN(filterValue, "=", 2)
+		var filterKey = filterArray[0]
+		if len(filterArray) > 1 {
+			filterValue = filterArray[1]
+		} else {
+			filterValue = ""
+		}
+		return func(p *libpod.Pod) bool {
+			for labelKey, labelValue := range p.Labels() {
+				if labelKey == filterKey && ("" == filterValue || labelValue == filterValue) {
+					return true
+				}
+			}
+			return false
+		}, nil
+	}
+	return nil, errors.Errorf("%s is an invalid filter", filter)
+}

pkg/api/handlers/utils/pods.go

@@ -59,6 +59,10 @@ func GetPods(w http.ResponseWriter, r *http.Request) ([]*entities.ListPodsReport
 		if err != nil {
 			return nil, err
 		}
+		infraId, err := pod.InfraContainerID()
+		if err != nil {
+			return nil, err
+		}
 		lp := entities.ListPodsReport{
 			Cgroup:    pod.CgroupParent(),
 			Created:   pod.CreatedTime(),
@@ -66,6 +70,7 @@ func GetPods(w http.ResponseWriter, r *http.Request) ([]*entities.ListPodsReport
 			Name:      pod.Name(),
 			Namespace: pod.Namespace(),
 			Status:    status,
+			InfraId:   infraId,
 		}
 		for _, ctr := range ctrs {
 			state, err := ctr.State()

pkg/domain/entities/engine_container.go

@@ -22,6 +22,7 @@ type ContainerEngine interface {
 	PodExists(ctx context.Context, nameOrId string) (*BoolReport, error)
 	PodKill(ctx context.Context, namesOrIds []string, options PodKillOptions) ([]*PodKillReport, error)
 	PodPause(ctx context.Context, namesOrIds []string, options PodPauseOptions) ([]*PodPauseReport, error)
+	PodPs(ctx context.Context, options PodPSOptions) ([]*ListPodsReport, error)
 	PodRestart(ctx context.Context, namesOrIds []string, options PodRestartOptions) ([]*PodRestartReport, error)
 	PodStart(ctx context.Context, namesOrIds []string, options PodStartOptions) ([]*PodStartReport, error)
 	PodStop(ctx context.Context, namesOrIds []string, options PodStopOptions) ([]*PodStopReport, error)

pkg/domain/entities/pods.go

@@ -22,6 +22,7 @@ type ListPodsReport struct {
 	Containers []*ListPodContainer
 	Created    time.Time
 	Id         string
+	InfraId    string
 	Name       string
 	Namespace  string
 	Status     string
@@ -151,3 +152,15 @@ type PodTopOptions struct {
 	Descriptors []string
 	NameOrID    string
 }
+
+type PodPSOptions struct {
+	CtrNames  bool
+	CtrIds    bool
+	CtrStatus bool
+	Filters   map[string][]string
+	Format    string
+	Latest    bool
+	Namespace bool
+	Quiet     bool
+	Sort      string
+}

pkg/domain/infra/abi/pods.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/libpod/define"
+	"github.com/containers/libpod/libpod/podfilters"
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/containers/libpod/pkg/signal"
 	"github.com/containers/libpod/pkg/specgen"
@@ -272,3 +273,61 @@ func (ic *ContainerEngine) PodTop(ctx context.Context, options entities.PodTopOp
 	report.Value, err = pod.GetPodPidInformation(options.Descriptors)
 	return report, err
 }
+
+func (ic *ContainerEngine) PodPs(ctx context.Context, options entities.PodPSOptions) ([]*entities.ListPodsReport, error) {
+	var (
+		filters []libpod.PodFilter
+		reports []*entities.ListPodsReport
+	)
+	for k, v := range options.Filters {
+		for _, filter := range v {
+			f, err := podfilters.GeneratePodFilterFunc(k, filter)
+			if err != nil {
+				return nil, err
+			}
+			filters = append(filters, f)
+
+		}
+	}
+	pds, err := ic.Libpod.Pods(filters...)
+	if err != nil {
+		return nil, err
+	}
+	for _, p := range pds {
+		var lpcs []*entities.ListPodContainer
+		status, err := p.GetPodStatus()
+		if err != nil {
+			return nil, err
+		}
+		cons, err := p.AllContainers()
+		if err != nil {
+			return nil, err
+		}
+		for _, c := range cons {
+			state, err := c.State()
+			if err != nil {
+				return nil, err
+			}
+			lpcs = append(lpcs, &entities.ListPodContainer{
+				Id:     c.ID(),
+				Names:  c.Name(),
+				Status: state.String(),
+			})
+		}
+		infraId, err := p.InfraContainerID()
+		if err != nil {
+			return nil, err
+		}
+		reports = append(reports, &entities.ListPodsReport{
+			Cgroup:     p.CgroupParent(),
+			Containers: lpcs,
+			Created:    p.CreatedTime(),
+			Id:         p.ID(),
+			InfraId:    infraId,
+			Name:       p.Name(),
+			Namespace:  p.Namespace(),
+			Status:     status,
+		})
+	}
+	return reports, nil
+}

pkg/domain/infra/tunnel/pods.go

@@ -193,3 +193,7 @@ func (ic *ContainerEngine) PodTop(ctx context.Context, options entities.PodTopOp
 	}
 	return &entities.StringSliceReport{Value: topOutput}, nil
 }
+
+func (ic *ContainerEngine) PodPs(ctx context.Context, options entities.PodPSOptions) ([]*entities.ListPodsReport, error) {
+	return pods.List(ic.ClientCxt, options.Filters)
+}