johnsonjh/gfpsgo

package main

import (
    "flag"
    "fmt"
    "os"
    "strings"
    "text/tabwriter"

    psgo "github.com/johnsonjh/gfpsgo"
    "github.com/sirupsen/logrus"
)

func main() {
    var (
        descriptors []string
        pidsList    []string
        data        [][]string
        err         error

        pids = flag.String(
            "pids",
            "",
            "comma separated list of process IDs to retrieve",
        )
        format = flag.String(
            "format",
            "",
            "ps(1) AIX format comma-separated string",
        )
        list = flag.Bool(
            "list",
            false,
            "list all supported descriptors",
        )
        join = flag.Bool(
            "join",
            false,
            "join namespace of provided pids (containers)",
        )
        fillMappings = flag.Bool(
            "fill-mappings",
            false,
            "fill the UID and GID mappings with the current user namespace",
        )
    )

    flag.Parse()

    if *fillMappings && !*join {
        fmt.Fprintln(os.Stderr, "-fill-mappings requires -join")
        os.Exit(1)
    }

    if *list {
        fmt.Println(strings.Join(psgo.ListDescriptors(), ", "))
        return
    }

    if *format != "" {
        descriptors = strings.Split(*format, ",")
    }

    if *pids != "" {
        pidsList = strings.Split(*pids, ",")
    }

    if len(pidsList) > 0 {
        opts := psgo.JoinNamespaceOpts{FillMappings: *fillMappings}

        if *join {
            data, err = psgo.JoinNamespaceAndProcessInfoByPidsWithOptions(
                pidsList,
                descriptors,
                &opts,
            )
        } else {
            data, err = psgo.ProcessInfoByPids(pidsList, descriptors)
        }
        if err != nil {
            logrus.Panic(err)
        }
    } else {
        data, err = psgo.ProcessInfo(descriptors)
        if err != nil {
            logrus.Panic(err)
        }
    }

    tw := tabwriter.NewWriter(os.Stdout, 5, 1, 3, ' ', 0)
    for _, d := range data {
        fmt.Fprintln(tw, strings.Join(d, "\t"))
    }
    err = tw.Flush()
    if err != nil {
        logrus.Panic(err)
    }
}