Esempio n. 1
0
func (cli *HyperClient) StopPod(podId, stopVm string) (int, string, error) {
	v := url.Values{}
	v.Set("podId", podId)
	v.Set("stopVm", stopVm)
	body, _, err := readBody(cli.call("POST", "/pod/stop?"+v.Encode(), nil, nil))
	if err != nil {
		if strings.Contains(err.Error(), "leveldb: not found") {
			return -1, "", fmt.Errorf("Can not find that POD ID to stop, please check your POD ID!")
		}
		return -1, "", err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return -1, "", err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return -1, "", err
	}
	out.Close()
	// This 'ID' stands for pod ID
	// This 'Code' should be E_SHUTDOWN
	// THis 'Cause' ..
	if remoteInfo.Exists("ID") {
		// TODO ...
	}
	return remoteInfo.GetInt("Code"), remoteInfo.Get("Cause"), nil
}
Esempio n. 2
0
func (daemon *Daemon) CmdInfo(job *engine.Job) error {
	cli := daemon.dockerCli
	body, _, err := cli.SendCmdInfo("")
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}
	if _, err := out.Write(body); err != nil {
		return fmt.Errorf("Error while reading remote info!\n")
	}
	out.Close()

	v := &engine.Env{}
	v.Set("ID", daemon.ID)
	if remoteInfo.Exists("Containers") {
		v.SetInt("Containers", remoteInfo.GetInt("Containers"))
	}

	// Get system infomation
	meminfo, err := sysinfo.GetMemInfo()
	osinfo, err := sysinfo.GetOSInfo()
	v.SetInt64("MemTotal", int64(meminfo.MemTotal))
	v.SetInt64("Pods", daemon.GetPodNum())
	v.Set("Operating System", osinfo.PrettyName)
	if hostname, err := os.Hostname(); err == nil {
		v.SetJson("Name", hostname)
	}
	if _, err := v.WriteTo(job.Stdout); err != nil {
		return err
	}
	return nil
}
Esempio n. 3
0
File: run.go Progetto: huangqg/hyper
func (cli *HyperClient) GetContainerByPod(podId string) (string, error) {
	v := url.Values{}
	v.Set("item", "container")
	body, _, err := readBody(cli.call("GET", "/list?"+v.Encode(), nil, nil))
	if err != nil {
		return "", err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return "", err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return "", err
	}
	out.Close()
	var containerResponse = []string{}
	containerResponse = remoteInfo.GetList("cData")
	for _, c := range containerResponse {
		fields := strings.Split(c, ":")
		containerId := fields[0]
		if podId == fields[1] {
			return containerId, nil
		}
	}

	return "", fmt.Errorf("Container not found")
}
Esempio n. 4
0
func (cli *HyperClient) GetPodInfo(podName string) (string, error) {
	// get the pod or container info before we start the exec
	v := url.Values{}
	v.Set("podName", podName)
	body, _, err := readBody(cli.call("GET", "/pod/info?"+v.Encode(), nil, nil))
	if err != nil {
		fmt.Printf("The Error is encountered, %s\n", err)
		return "", err
	}

	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return "", err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return "", err
	}
	out.Close()
	if remoteInfo.Exists("hostname") {
		hostname := remoteInfo.Get("hostname")
		if hostname == "" {
			return "", nil
		} else {
			return hostname, nil
		}
	}

	return "", nil
}
Esempio n. 5
0
func (daemon *Daemon) CmdCreate(job *engine.Job) error {
	imgName := job.Args[0]
	cli := daemon.dockerCli
	body, _, err := cli.SendCmdCreate(imgName)
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}
	if _, err := out.Write(body); err != nil {
		return fmt.Errorf("Error while reading remote info!\n")
	}
	out.Close()

	v := &engine.Env{}
	v.SetJson("ID", daemon.ID)
	containerId := remoteInfo.Get("Id")
	if containerId != "" {
		v.Set("ContainerID", containerId)
		glog.V(3).Infof("The ContainerID is %s\n", containerId)
	} else {
		return fmt.Errorf("Hyper ERROR: AN error encountered during creating container!\n")
	}

	if _, err := v.WriteTo(job.Stdout); err != nil {
		return err
	}

	return nil
}
Esempio n. 6
0
File: pod.go Progetto: huangqg/hyper
func (cli *HyperClient) CreatePod(jsonbody string) (string, error) {
	v := url.Values{}
	v.Set("podArgs", jsonbody)
	body, _, err := readBody(cli.call("POST", "/pod/create?"+v.Encode(), nil, nil))
	if err != nil {
		return "", err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return "", err
	}

	if _, err := out.Write(body); err != nil {
		return "", fmt.Errorf("Error reading remote info: %s", err)
	}
	out.Close()
	errCode := remoteInfo.GetInt("Code")
	if errCode == types.E_OK {
		//fmt.Println("VM is successful to start!")
	} else {
		// case types.E_CONTEXT_INIT_FAIL:
		// case types.E_DEVICE_FAIL:
		// case types.E_QMP_INIT_FAIL:
		// case types.E_QMP_COMMAND_FAIL:
		if errCode != types.E_BAD_REQUEST &&
			errCode != types.E_FAILED {
			return "", fmt.Errorf("Error code is %d", errCode)
		} else {
			return "", fmt.Errorf("Cause is %s", remoteInfo.Get("Cause"))
		}
	}
	return remoteInfo.Get("ID"), nil
}
Esempio n. 7
0
File: vm.go Progetto: huangqg/hyper
func (cli *HyperClient) HyperCmdVm(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "vm\n\nRun a VM, without any Pod running on it"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}

	// Only run a new VM
	body, _, err := readBody(cli.call("POST", "/vm/create", nil, nil))
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		return fmt.Errorf("Error reading remote info: %s", err)
	}
	out.Close()
	errCode := remoteInfo.GetInt("Code")
	if errCode == types.E_OK {
		//fmt.Println("VM is successful to start!")
	} else {
		// case types.E_CONTEXT_INIT_FAIL:
		// case types.E_DEVICE_FAIL:
		// case types.E_QMP_INIT_FAIL:
		// case types.E_QMP_COMMAND_FAIL:
		if errCode != types.E_BAD_REQUEST &&
			errCode != types.E_FAILED {
			return fmt.Errorf("Error code is %d", errCode)
		} else {
			return fmt.Errorf("Cause is %s", remoteInfo.Get("Cause"))
		}
	}
	fmt.Printf("New VM id is %s\n", remoteInfo.Get("ID"))
	return nil
}
Esempio n. 8
0
File: rm.go Progetto: huangqg/hyper
func (cli *HyperClient) HyperCmdRm(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "rm POD_ID\n\ndestroy a pod"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	if len(args) < 2 {
		return fmt.Errorf("\"rm\" requires a minimum of 1 argument, please provide POD ID.\n")
	}
	podId := args[1]
	v := url.Values{}
	v.Set("podId", podId)
	body, _, err := readBody(cli.call("POST", "/pod/remove?"+v.Encode(), nil, nil))
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		return fmt.Errorf("Error reading remote info: %s", err)
	}
	out.Close()
	errCode := remoteInfo.GetInt("Code")
	if errCode == types.E_OK || errCode == types.E_VM_SHUTDOWN {
		//fmt.Println("VM is successful to start!")
	} else {
		return fmt.Errorf("Error code is %d, Cause is %s", remoteInfo.GetInt("Code"), remoteInfo.Get("Cause"))
	}
	fmt.Printf("Pod(%s) is successful to be deleted!\n", podId)
	return nil
}
Esempio n. 9
0
func (cli *HyperClient) HyperCmdKill(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "kill VM_ID\n\nterminate a VM instance"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	if len(args) == 1 {
		return fmt.Errorf("\"kill\" requires a minimum of 1 argument, please provide VM ID.\n")
	}

	vmId := args[1]
	v := url.Values{}
	v.Set("vm", vmId)
	body, _, err := readBody(cli.call("POST", "/vm/kill?"+v.Encode(), nil, nil))
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return err
	}
	out.Close()
	if remoteInfo.Exists("ID") {
		// TODO ...
	}

	return nil
}
Esempio n. 10
0
// we need this *info* function to get the whole status from the docker daemon
func (cli *HyperClient) HyperCmdInfo(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "info\n\ndisplay system-wide information"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	body, _, err := readBody(cli.call("GET", "/info", nil, nil))
	if err != nil {
		fmt.Printf("An error is encountered, %s\n", err)
		return err
	}

	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return err
	}
	out.Close()
	if remoteInfo.Exists("Containers") {
		fmt.Printf("Containers: %d\n", remoteInfo.GetInt("Containers"))
	}
	fmt.Printf("PODs: %d\n", remoteInfo.GetInt("Pods"))
	memTotal := remoteInfo.GetInt("MemTotal")
	fmt.Printf("Total Memory: %d KB\n", memTotal)
	fmt.Printf("Operating System: %s\n", remoteInfo.Get("Operating System"))

	return nil
}
Esempio n. 11
0
func NewDaemonFromDirectory(eng *engine.Engine) (*Daemon, error) {
	// register portallocator release on shutdown
	eng.OnShutdown(func() {
		if err := portallocator.ReleaseAll(); err != nil {
			glog.Errorf("portallocator.ReleaseAll(): %s", err.Error())
		}
	})
	// Check that the system is supported and we have sufficient privileges
	if runtime.GOOS != "linux" {
		return nil, fmt.Errorf("The Docker daemon is only supported on linux")
	}
	if os.Geteuid() != 0 {
		return nil, fmt.Errorf("The Docker daemon needs to be run as root")
	}
	if err := checkKernel(); err != nil {
		return nil, err
	}

	cfg, err := goconfig.LoadConfigFile(eng.Config)
	if err != nil {
		glog.Errorf("Read config file (%s) failed, %s", eng.Config, err.Error())
		return nil, err
	}
	kernel, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Kernel")
	initrd, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Initrd")
	glog.V(0).Infof("The config: kernel=%s, initrd=%s", kernel, initrd)
	biface, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Bridge")
	bridgeip, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "BridgeIP")
	glog.V(0).Infof("The config: bridge=%s, ip=%s", biface, bridgeip)
	bios, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Bios")
	cbfs, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Cbfs")
	glog.V(0).Infof("The config: bios=%s, cbfs=%s", bios, cbfs)
	host, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Host")

	var tempdir = "/var/run/hyper/"
	os.Setenv("TMPDIR", tempdir)
	if err := os.MkdirAll(tempdir, 0755); err != nil && !os.IsExist(err) {
		return nil, err
	}

	var realRoot = "/var/lib/hyper/"
	// Create the root directory if it doesn't exists
	if err := os.MkdirAll(realRoot, 0755); err != nil && !os.IsExist(err) {
		return nil, err
	}

	if err := network.InitNetwork(biface, bridgeip); err != nil {
		glog.Errorf("InitNetwork failed, %s\n", err.Error())
		return nil, err
	}

	var (
		proto   = "unix"
		addr    = "/var/run/docker.sock"
		db_file = fmt.Sprintf("%s/hyper.db", realRoot)
	)
	db, err := leveldb.OpenFile(db_file, nil)
	if err != nil {
		glog.Errorf("open leveldb file failed, %s\n", err.Error())
		return nil, err
	}
	dockerCli := docker.NewDockerCli("", proto, addr, nil)
	qemuchan := map[string]interface{}{}
	qemuclient := map[string]interface{}{}
	subQemuClient := map[string]interface{}{}
	cList := []*Container{}
	pList := map[string]*Pod{}
	vList := map[string]*Vm{}
	daemon := &Daemon{
		ID:                fmt.Sprintf("%d", os.Getpid()),
		db:                db,
		eng:               eng,
		kernel:            kernel,
		initrd:            initrd,
		bios:              bios,
		cbfs:              cbfs,
		dockerCli:         dockerCli,
		containerList:     cList,
		podList:           pList,
		vmList:            vList,
		qemuChan:          qemuchan,
		qemuClientChan:    qemuclient,
		subQemuClientChan: subQemuClient,
		Host:              host,
	}

	stor := &Storage{}
	// Get the docker daemon info
	body, _, err := dockerCli.SendCmdInfo()
	if err != nil {
		return nil, err
	}
	outInfo := engine.NewOutput()
	remoteInfo, err := outInfo.AddEnv()
	if err != nil {
		return nil, err
	}
	if _, err := outInfo.Write(body); err != nil {
		return nil, fmt.Errorf("Error while reading remote info!\n")
	}
	outInfo.Close()
	storageDriver := remoteInfo.Get("Driver")
	stor.StorageType = storageDriver
	if storageDriver == "devicemapper" {
		if remoteInfo.Exists("DriverStatus") {
			var driverStatus [][2]string
			if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
				return nil, err
			}
			for _, pair := range driverStatus {
				if pair[0] == "Pool Name" {
					stor.PoolName = pair[1]
				}
				if pair[0] == "Backing Filesystem" {
					if strings.Contains(pair[1], "ext") {
						stor.Fstype = "ext4"
					} else if strings.Contains(pair[1], "xfs") {
						stor.Fstype = "xfs"
					} else {
						stor.Fstype = "dir"
					}
					break
				}
			}
		}
	} else {
		if remoteInfo.Exists("DriverStatus") {
			var driverStatus [][2]string
			if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
				return nil, err
			}
			for _, pair := range driverStatus {
				if pair[0] == "Root Dir" {
					stor.RootPath = pair[1]
				}
				if pair[0] == "Backing Filesystem" {
					stor.Fstype = "dir"
					break
				}
			}
		}
	}
	daemon.Storage = stor
	dmPool := dm.DeviceMapper{
		Datafile:         "/var/lib/hyper/data",
		Metadatafile:     "/var/lib/hyper/metadata",
		DataLoopFile:     "/dev/loop6",
		MetadataLoopFile: "/dev/loop7",
		PoolName:         "hyper-volume-pool",
		Size:             20971520 * 512,
	}
	if storageDriver == "devicemapper" {
		daemon.Storage.DmPoolData = &dmPool
		// Prepare the DeviceMapper storage
		if err := dm.CreatePool(&dmPool); err != nil {
			return nil, err
		}
	} else {
		daemon.CleanVolume(0)
	}
	eng.OnShutdown(func() {
		if err := daemon.shutdown(); err != nil {
			glog.Errorf("Error during daemon.shutdown(): %v", err)
		}
	})

	return daemon, nil
}
Esempio n. 12
0
func (daemon *Daemon) CreatePod(podArgs, podId string, wg *sync.WaitGroup) error {
	userPod, err := pod.ProcessPodBytes([]byte(podArgs))
	if err != nil {
		glog.V(1).Infof("Process POD file error: %s", err.Error())
		return err
	}
	if err := userPod.Validate(); err != nil {
		return err
	}
	// store the UserPod into the db
	if err := daemon.WritePodToDB(podId, []byte(podArgs)); err != nil {
		glog.V(1).Info("Found an error while saveing the POD file")
		return err
	}
	containerIds, err := daemon.GetPodContainersByName(podId)
	if err != nil {
		glog.V(1).Info(err.Error())
	}
	if containerIds != nil {
		for _, id := range containerIds {
			daemon.SetPodByContainer(id, podId, "", "", []string{}, types.S_POD_CREATED)
		}
	} else {
		// Process the 'Containers' section
		glog.V(1).Info("Process the Containers section in POD SPEC\n")
		for _, c := range userPod.Containers {
			imgName := c.Image
			body, _, err := daemon.dockerCli.SendCmdCreate(imgName)
			if err != nil {
				glog.Error(err.Error())
				daemon.DeletePodFromDB(podId)
				return err
			}
			out := engine.NewOutput()
			remoteInfo, err := out.AddEnv()
			if err != nil {
				daemon.DeletePodFromDB(podId)
				return err
			}
			if _, err := out.Write(body); err != nil {
				daemon.DeletePodFromDB(podId)
				return fmt.Errorf("Error while reading remote info!\n")
			}
			out.Close()

			containerId := remoteInfo.Get("Id")
			daemon.SetPodByContainer(containerId, podId, "", "", []string{}, types.S_POD_CREATED)
		}
	}
	containers := []*Container{}
	for _, v := range daemon.containerList {
		if v.PodId == podId {
			containers = append(containers, v)
		}
	}
	mypod := &Pod{
		Id:            podId,
		Name:          userPod.Name,
		Vm:            "",
		Wg:            wg,
		Containers:    containers,
		Status:        types.S_POD_CREATED,
		Type:          userPod.Type,
		RestartPolicy: userPod.Containers[0].RestartPolicy,
	}
	daemon.AddPod(mypod)

	return nil
}
Esempio n. 13
0
File: pod.go Progetto: huangqg/hyper
func (cli *HyperClient) HyperCmdStart(args ...string) error {
	var opts struct {
		//		OnlyVm    bool     `long:"onlyvm" default:"false" value-name:"false" description:"Only start a new VM"`
		Cpu int `short:"c" long:"cpu" default:"1" value-name:"1" description:"CPU number for the VM"`
		Mem int `short:"m" long:"memory" default:"128" value-name:"128" description:"Memory size (MB) for the VM"`
	}
	var parser = gflag.NewParser(&opts, gflag.Default)
	parser.Usage = "start [-c 1 -m 128]| POD_ID \n\nlaunch a 'pending' pod"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	if false {
		// Only run a new VM
		v := url.Values{}
		v.Set("cpu", fmt.Sprintf("%d", opts.Cpu))
		v.Set("mem", fmt.Sprintf("%d", opts.Mem))
		body, _, err := readBody(cli.call("POST", "/vm/create?"+v.Encode(), nil, nil))
		if err != nil {
			return err
		}
		out := engine.NewOutput()
		remoteInfo, err := out.AddEnv()
		if err != nil {
			return err
		}

		if _, err := out.Write(body); err != nil {
			return fmt.Errorf("Error reading remote info: %s", err)
		}
		out.Close()
		errCode := remoteInfo.GetInt("Code")
		if errCode == types.E_OK {
			//fmt.Println("VM is successful to start!")
		} else {
			// case types.E_CONTEXT_INIT_FAIL:
			// case types.E_DEVICE_FAIL:
			// case types.E_QMP_INIT_FAIL:
			// case types.E_QMP_COMMAND_FAIL:
			if errCode != types.E_BAD_REQUEST &&
				errCode != types.E_FAILED {
				return fmt.Errorf("Error code is %d", errCode)
			} else {
				return fmt.Errorf("Cause is %s", remoteInfo.Get("Cause"))
			}
		}
		fmt.Printf("New VM id is %s\n", remoteInfo.Get("ID"))
		return nil
	}
	if len(args) < 2 {
		return fmt.Errorf("\"start\" requires a minimum of 1 argument, please provide POD ID.\n")
	}
	var (
		podId string
		vmId  string
	)
	if len(args) == 2 {
		podId = args[1]
	}
	if len(args) == 3 {
		podId = args[1]
		vmId = args[2]
	}
	// fmt.Printf("Pod ID is %s, VM ID is %s\n", podId, vmId)
	_, err = cli.StartPod(podId, vmId)
	if err != nil {
		return err
	}
	fmt.Printf("Successfully started the Pod(%s)\n", podId)
	return nil
}
Esempio n. 14
0
func (cli *HyperClient) HyperCmdList(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "list [pod|container]\n\nlist all pods or container information"
	args, err := parser.Parse()
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	var item string
	if len(args) == 1 {
		item = "pod"
	} else {
		item = args[1]
	}

	if item != "pod" && item != "vm" && item != "container" {
		return fmt.Errorf("Error, the %s can not support %s list!", os.Args[0], item)
	}

	v := url.Values{}
	v.Set("item", item)
	body, _, err := readBody(cli.call("GET", "/list?"+v.Encode(), nil, nil))
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return err
	}
	out.Close()

	var (
		vmResponse        = []string{}
		podResponse       = []string{}
		containerResponse = []string{}
	)
	if remoteInfo.Exists("item") {
		item = remoteInfo.Get("item")
	}
	if remoteInfo.Exists("Error") {
		return fmt.Errorf("Found an error while getting %s list: %s", item, remoteInfo.Get("Error"))
	}

	if item == "vm" {
		vmResponse = remoteInfo.GetList("vmData")
	}
	if item == "pod" {
		podResponse = remoteInfo.GetList("podData")
	}
	if item == "container" {
		containerResponse = remoteInfo.GetList("cData")
	}

	//fmt.Printf("Item is %s\n", item)
	if item == "vm" {
		fmt.Printf("%15s%20s\n", "VM name", "Status")
		for _, vm := range vmResponse {
			fields := strings.Split(vm, ":")
			fmt.Printf("%15s%20s\n", fields[0], fields[2])
		}
	}

	if item == "pod" {
		fmt.Printf("%15s%30s%20s%10s\n", "POD ID", "POD Name", "VM name", "Status")
		for _, p := range podResponse {
			fields := strings.Split(p, ":")
			var podName = fields[1]
			if len(fields[1]) > 27 {
				podName = fields[1][:27]
			}
			fmt.Printf("%15s%30s%20s%10s\n", fields[0], podName, fields[2], fields[3])
		}
	}

	if item == "container" {
		fmt.Printf("%-66s%15s%10s\n", "Container ID", "POD ID", "Status")
		for _, c := range containerResponse {
			fields := strings.Split(c, ":")
			fmt.Printf("%-66s%15s%10s\n", fields[0], fields[1], fields[2])
		}
	}
	return nil
}