podman-remote ps

add the ability to run ps on containers using the remote client.

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

1 files changed, 170 insertions, 1 deletions

diff --git a/cmd/podman/shared/container.go b/cmd/podman/shared/container.go
index 6826191c5..7bef62355 100644
--- a/cmd/podman/shared/container.go
+++ b/cmd/podman/shared/container.go
@@ -44,7 +44,6 @@ type PsOptions struct {
 	Quiet     bool
 	Size      bool
 	Sort      string
-	Label     string
 	Namespace bool
 	Sync      bool
 }
@@ -274,6 +273,176 @@ func worker(wg *sync.WaitGroup, jobs <-chan workerInput, results chan<- PsContai
 	}
 }
 
+func generateContainerFilterFuncs(filter, filterValue string, r *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":
+		var filterArray []string = strings.SplitN(filterValue, "=", 2)
+		var filterKey string = filterArray[0]
+		if len(filterArray) > 1 {
+			filterValue = filterArray[1]
+		} else {
+			filterValue = ""
+		}
+		return func(c *libpod.Container) bool {
+			for labelKey, labelValue := range c.Labels() {
+				if labelKey == filterKey && ("" == filterValue || labelValue == 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, exited, err := c.ExitCode()
+			if ec == int32(exitCode) && err == nil && exited == true {
+				return true
+			}
+			return false
+		}, nil
+	case "status":
+		if !util.StringInSlice(filterValue, []string{"created", "running", "paused", "stopped", "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
+			}
+			if filterValue == "stopped" {
+				filterValue = "exited"
+			}
+			state := status.String()
+			if status == libpod.ContainerStateConfigured {
+				state = "created"
+			} else if status == libpod.ContainerStateStopped {
+				state = "exited"
+			}
+			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 := r.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 := r.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
+	case "health":
+		return func(c *libpod.Container) bool {
+			hcStatus, err := c.HealthCheckStatus()
+			if err != nil {
+				return false
+			}
+			return hcStatus == filterValue
+		}, nil
+	}
+	return nil, errors.Errorf("%s is an invalid filter", filter)
+}
+
+// GetPsContainerOutput returns a slice of containers specifically for ps output
+func GetPsContainerOutput(r *libpod.Runtime, opts PsOptions, filters []string, maxWorkers int) ([]PsContainerOutput, error) {
+	var (
+		filterFuncs      []libpod.ContainerFilter
+		outputContainers []*libpod.Container
+	)
+
+	if len(filters) > 0 {
+		for _, f := range filters {
+			filterSplit := strings.SplitN(f, "=", 2)
+			if len(filterSplit) < 2 {
+				return nil, errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
+			}
+			generatedFunc, err := generateContainerFilterFuncs(filterSplit[0], filterSplit[1], r)
+			if err != nil {
+				return nil, errors.Wrapf(err, "invalid filter")
+			}
+			filterFuncs = append(filterFuncs, generatedFunc)
+		}
+	}
+	if !opts.Latest {
+		// Get all containers
+		containers, err := r.GetContainers(filterFuncs...)
+		if err != nil {
+			return nil, err
+		}
+
+		// We only want the last few containers
+		if opts.Last > 0 && opts.Last <= len(containers) {
+			return nil, errors.Errorf("--last not yet supported")
+		} else {
+			outputContainers = containers
+		}
+	} else {
+		// Get just the latest container
+		// Ignore filters
+		latestCtr, err := r.GetLatestContainer()
+		if err != nil {
+			return nil, err
+		}
+
+		outputContainers = []*libpod.Container{latestCtr}
+	}
+
+	pss := PBatch(outputContainers, maxWorkers, opts)
+	return pss, nil
+}
+
 // PBatch is performs batch operations on a container in parallel. It spawns the number of workers
 // relative to the the number of parallel operations desired.
 func PBatch(containers []*libpod.Container, workers int, opts PsOptions) []PsContainerOutput {