Update kpod info to use new libpod api

Signed-off-by: umohnani8 <umohnani@redhat.com>

Closes: #124
Approved by: mheon

cmd/kpod/info.go

@@ -1,15 +1,11 @@
 package main
 
 import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
 	"runtime"
 
-	"github.com/docker/docker/pkg/system"
 	"github.com/pkg/errors"
 	"github.com/projectatomic/libpod/cmd/kpod/formats"
+	"github.com/projectatomic/libpod/libpod"
 	"github.com/urfave/cli"
 )
 
@@ -41,22 +37,24 @@ func infoCmd(c *cli.Context) error {
 	}
 	info := map[string]interface{}{}
 
-	infoGivers := []infoGiverFunc{
+	runtime, err := getRuntime(c)
-		storeInfo,
+	if err != nil {
-		hostInfo,
+		return errors.Wrapf(err, "could not get runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	infoArr, err := runtime.Info()
+	if err != nil {
+		return errors.Wrapf(err, "error getting info")
 	}
 
 	if c.Bool("debug") {
-		infoGivers = append(infoGivers, debugInfo)
+		debugInfo := debugInfo(c)
+		infoArr = append(infoArr, libpod.InfoData{Type: "debug", Data: debugInfo})
 	}
 
-	for _, giver := range infoGivers {
+	for _, currInfo := range infoArr {
-		thisName, thisInfo, err := giver(c)
+		info[currInfo.Type] = currInfo.Data
-		if err != nil {
-			info[thisName] = infoErr(err)
-			continue
-		}
-		info[thisName] = thisInfo
 	}
 
 	var out formats.Writer
@@ -75,126 +73,12 @@ func infoCmd(c *cli.Context) error {
 	return nil
 }
 
-func infoErr(err error) map[string]interface{} {
-	return map[string]interface{}{
-		"error": err.Error(),
-	}
-}
-
-type infoGiverFunc func(c *cli.Context) (name string, info map[string]interface{}, err error)
-
 // top-level "debug" info
-func debugInfo(c *cli.Context) (string, map[string]interface{}, error) {
+func debugInfo(c *cli.Context) map[string]interface{} {
 	info := map[string]interface{}{}
 	info["compiler"] = runtime.Compiler
 	info["go version"] = runtime.Version()
 	info["kpod version"] = c.App.Version
 	info["git commit"] = gitCommit
-	return "debug", info, nil
+	return info
-}
-
-// top-level "host" info
-func hostInfo(c *cli.Context) (string, map[string]interface{}, error) {
-	// lets say OS, arch, number of cpus, amount of memory, maybe os distribution/version, hostname, kernel version, uptime
-	info := map[string]interface{}{}
-	info["os"] = runtime.GOOS
-	info["arch"] = runtime.GOARCH
-	info["cpus"] = runtime.NumCPU()
-	mi, err := system.ReadMemInfo()
-	if err != nil {
-		info["meminfo"] = infoErr(err)
-	} else {
-		// TODO this might be a place for github.com/dustin/go-humanize
-		info["MemTotal"] = mi.MemTotal
-		info["MemFree"] = mi.MemFree
-		info["SwapTotal"] = mi.SwapTotal
-		info["SwapFree"] = mi.SwapFree
-	}
-	if kv, err := readKernelVersion(); err != nil {
-		info["kernel"] = infoErr(err)
-	} else {
-		info["kernel"] = kv
-	}
-
-	if up, err := readUptime(); err != nil {
-		info["uptime"] = infoErr(err)
-	} else {
-		info["uptime"] = up
-	}
-	if host, err := os.Hostname(); err != nil {
-		info["hostname"] = infoErr(err)
-	} else {
-		info["hostname"] = host
-	}
-	return "host", info, nil
-}
-
-// top-level "store" info
-func storeInfo(c *cli.Context) (string, map[string]interface{}, error) {
-	storeStr := "store"
-	config, err := getConfig(c)
-	if err != nil {
-		return storeStr, nil, errors.Wrapf(err, "Could not get config")
-	}
-	store, err := getStore(config)
-	if err != nil {
-		return storeStr, nil, err
-	}
-
-	// lets say storage driver in use, number of images, number of containers
-	info := map[string]interface{}{}
-	info["GraphRoot"] = store.GraphRoot()
-	info["RunRoot"] = store.RunRoot()
-	info["GraphDriverName"] = store.GraphDriverName()
-	info["GraphOptions"] = store.GraphOptions()
-	statusPairs, err := store.Status()
-	if err != nil {
-		return storeStr, nil, err
-	}
-	status := map[string]string{}
-	for _, pair := range statusPairs {
-		status[pair[0]] = pair[1]
-	}
-	info["GraphStatus"] = status
-	images, err := store.Images()
-	if err != nil {
-		info["ImageStore"] = infoErr(err)
-	} else {
-		info["ImageStore"] = map[string]interface{}{
-			"number": len(images),
-		}
-	}
-	containers, err := store.Containers()
-	if err != nil {
-		info["ContainerStore"] = infoErr(err)
-	} else {
-		info["ContainerStore"] = map[string]interface{}{
-			"number": len(containers),
-		}
-	}
-	return storeStr, info, nil
-}
-
-func readKernelVersion() (string, error) {
-	buf, err := ioutil.ReadFile("/proc/version")
-	if err != nil {
-		return "", err
-	}
-	f := bytes.Fields(buf)
-	if len(f) < 2 {
-		return string(bytes.TrimSpace(buf)), nil
-	}
-	return string(f[2]), nil
-}
-
-func readUptime() (string, error) {
-	buf, err := ioutil.ReadFile("/proc/uptime")
-	if err != nil {
-		return "", err
-	}
-	f := bytes.Fields(buf)
-	if len(f) < 1 {
-		return "", fmt.Errorf("invalid uptime")
-	}
-	return string(f[0]), nil
 }

libpod/info.go

@@ -0,0 +1,116 @@
+package libpod
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"runtime"
+
+	"github.com/docker/docker/pkg/system"
+	"github.com/pkg/errors"
+)
+
+// InfoData holds the info type, i.e store, host etc and the data for each type
+type InfoData struct {
+	Type string
+	Data map[string]interface{}
+}
+
+// top-level "host" info
+func (r *Runtime) hostInfo() (map[string]interface{}, error) {
+	// lets say OS, arch, number of cpus, amount of memory, maybe os distribution/version, hostname, kernel version, uptime
+	info := map[string]interface{}{}
+	info["os"] = runtime.GOOS
+	info["arch"] = runtime.GOARCH
+	info["cpus"] = runtime.NumCPU()
+	mi, err := system.ReadMemInfo()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error reading memory info")
+	}
+	// TODO this might be a place for github.com/dustin/go-humanize
+	info["MemTotal"] = mi.MemTotal
+	info["MemFree"] = mi.MemFree
+	info["SwapTotal"] = mi.SwapTotal
+	info["SwapFree"] = mi.SwapFree
+
+	kv, err := readKernelVersion()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error reading kernet version")
+	}
+	info["kernel"] = kv
+
+	up, err := readUptime()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error reading up time")
+	}
+	info["uptime"] = up
+
+	host, err := os.Hostname()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error getting hostname")
+	}
+	info["hostname"] = host
+
+	return info, nil
+}
+
+// top-level "store" info
+func (r *Runtime) storeInfo() (map[string]interface{}, error) {
+	// lets say storage driver in use, number of images, number of containers
+	info := map[string]interface{}{}
+	info["GraphRoot"] = r.store.GraphRoot()
+	info["RunRoot"] = r.store.RunRoot()
+	info["GraphDriverName"] = r.store.GraphDriverName()
+	info["GraphOptions"] = r.store.GraphOptions()
+	statusPairs, err := r.store.Status()
+	if err != nil {
+		return nil, err
+	}
+	status := map[string]string{}
+	for _, pair := range statusPairs {
+		status[pair[0]] = pair[1]
+	}
+	info["GraphStatus"] = status
+	images, err := r.store.Images()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error getting number of images")
+	}
+	info["ImageStore"] = map[string]interface{}{
+		"number": len(images),
+	}
+
+	containers, err := r.store.Containers()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error getting number of containers")
+	}
+	info["ContainerStore"] = map[string]interface{}{
+		"number": len(containers),
+	}
+
+	return info, nil
+}
+
+func readKernelVersion() (string, error) {
+	buf, err := ioutil.ReadFile("/proc/version")
+	if err != nil {
+		return "", err
+	}
+	f := bytes.Fields(buf)
+	if len(f) < 2 {
+		return string(bytes.TrimSpace(buf)), nil
+	}
+	return string(f[2]), nil
+}
+
+func readUptime() (string, error) {
+	buf, err := ioutil.ReadFile("/proc/uptime")
+	if err != nil {
+		return "", err
+	}
+	f := bytes.Fields(buf)
+	if len(f) < 1 {
+		return "", fmt.Errorf("invalid uptime")
+	}
+	return string(f[0]), nil
+}

libpod/runtime.go

@@ -309,3 +309,23 @@ func (r *Runtime) refresh(alivePath string) error {
 
 	return nil
 }
+
+// Info returns the store and host information
+func (r *Runtime) Info() ([]InfoData, error) {
+	info := []InfoData{}
+	// get host information
+	hostInfo, err := r.hostInfo()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error getting host info")
+	}
+	info = append(info, InfoData{Type: "host", Data: hostInfo})
+
+	// get store information
+	storeInfo, err := r.storeInfo()
+	if err != nil {
+		return nil, errors.Wrapf(err, "error getting store info")
+	}
+	info = append(info, InfoData{Type: "store", Data: storeInfo})
+
+	return info, nil
+}