8 files changed, 426 insertions, 2 deletions
diff --git a/cmd/podmanV2/common/create.go b/cmd/podmanV2/common/create.go
index 724ed2f42..f81d021c8 100644
--- a/cmd/podmanV2/common/create.go
+++ b/cmd/podmanV2/common/create.go
@@ -138,7 +138,7 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 	)
 	createFlags.StringVar(
 		&cf.DetachKeys,
-		"detach-keys", getDefaultDetachKeys(),
+		"detach-keys", GetDefaultDetachKeys(),
 		"Override the key sequence for detaching a container. Format is a single character `[a-Z]` or a comma separated sequence of `ctrl-<value>`, where `<value>` is one of: `a-cf`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`",
 	)
 	createFlags.StringSliceVar(
diff --git a/cmd/podmanV2/common/default.go b/cmd/podmanV2/common/default.go
index fea161edf..b71fcb6f0 100644
--- a/cmd/podmanV2/common/default.go
+++ b/cmd/podmanV2/common/default.go
@@ -116,6 +116,6 @@ func getDefaultPidsDescription() string {
 	return "Tune container pids limit (set 0 for unlimited)"
 }
 
-func getDefaultDetachKeys() string {
+func GetDefaultDetachKeys() string {
 	return defaultContainerConfig.Engine.DetachKeys
 }
diff --git a/cmd/podmanV2/containers/attach.go b/cmd/podmanV2/containers/attach.go
new file mode 100644
index 000000000..d62dcff86
--- /dev/null
+++ b/cmd/podmanV2/containers/attach.go
@@ -0,0 +1,60 @@
+package containers
+
+import (
+	"os"
+
+	"github.com/containers/libpod/cmd/podmanV2/common"
+	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	attachDescription = "The podman attach command allows you to attach to a running container using the container's ID or name, either to view its ongoing output or to control it interactively."
+	attachCommand     = &cobra.Command{
+		Use:   "attach [flags] CONTAINER",
+		Short: "Attach to a running container",
+		Long:  attachDescription,
+		RunE:  attach,
+		Args: func(cmd *cobra.Command, args []string) error {
+			if len(args) > 1 || (len(args) == 0 && !cmd.Flag("latest").Changed) {
+				return errors.Errorf("attach requires the name or id of one running container or the latest flag")
+			}
+			return nil
+		},
+		PreRunE: preRunE,
+		Example: `podman attach ctrID
+  podman attach 1234
+  podman attach --no-stdin foobar`,
+	}
+)
+
+var (
+	attachOpts entities.AttachOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: attachCommand,
+	})
+	flags := attachCommand.Flags()
+	flags.StringVar(&attachOpts.DetachKeys, "detach-keys", common.GetDefaultDetachKeys(), "Select the key sequence for detaching a container. Format is a single character `[a-Z]` or a comma separated sequence of `ctrl-<value>`, where `<value>` is one of: `a-z`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
+	flags.BoolVar(&attachOpts.NoStdin, "no-stdin", false, "Do not attach STDIN. The default is false")
+	flags.BoolVar(&attachOpts.SigProxy, "sig-proxy", true, "Proxy received signals to the process")
+	flags.BoolVarP(&attachOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+	}
+}
+
+func attach(cmd *cobra.Command, args []string) error {
+	attachOpts.Stdin = os.Stdin
+	if attachOpts.NoStdin {
+		attachOpts.Stdin = nil
+	}
+	attachOpts.Stdout = os.Stdout
+	attachOpts.Stderr = os.Stderr
+	return registry.ContainerEngine().ContainerAttach(registry.GetContext(), args[0], attachOpts)
+}
diff --git a/cmd/podmanV2/containers/exec.go b/cmd/podmanV2/containers/exec.go
new file mode 100644
index 000000000..4bff57dbb
--- /dev/null
+++ b/cmd/podmanV2/containers/exec.go
@@ -0,0 +1,93 @@
+package containers
+
+import (
+	"bufio"
+	"os"
+
+	"github.com/containers/libpod/cmd/podmanV2/common"
+	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/pkg/domain/entities"
+	envLib "github.com/containers/libpod/pkg/env"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	execDescription = `Execute the specified command inside a running container.
+`
+	execCommand = &cobra.Command{
+		Use:     "exec [flags] CONTAINER [COMMAND [ARG...]]",
+		Short:   "Run a process in a running container",
+		Long:    execDescription,
+		PreRunE: preRunE,
+		RunE:    exec,
+		Example: `podman exec -it ctrID ls
+  podman exec -it -w /tmp myCtr pwd
+  podman exec --user root ctrID ls`,
+	}
+)
+
+var (
+	envInput, envFile []string
+	execOpts          entities.ExecOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: execCommand,
+	})
+	flags := execCommand.Flags()
+	flags.SetInterspersed(false)
+	flags.StringVar(&execOpts.DetachKeys, "detach-keys", common.GetDefaultDetachKeys(), "Select the key sequence for detaching a container. Format is a single character [a-Z] or ctrl-<value> where <value> is one of: a-z, @, ^, [, , or _")
+	flags.StringArrayVarP(&envInput, "env", "e", []string{}, "Set environment variables")
+	flags.StringSliceVar(&envFile, "env-file", []string{}, "Read in a file of environment variables")
+	flags.BoolVarP(&execOpts.Interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
+	flags.BoolVarP(&execOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	flags.BoolVar(&execOpts.Privileged, "privileged", false, "Give the process extended Linux capabilities inside the container.  The default is false")
+	flags.BoolVarP(&execOpts.Tty, "tty", "t", false, "Allocate a pseudo-TTY. The default is false")
+	flags.StringVarP(&execOpts.User, "user", "u", "", "Sets the username or UID used and optionally the groupname or GID for the specified command")
+	flags.UintVar(&execOpts.PreserveFDs, "preserve-fds", 0, "Pass N additional file descriptors to the container")
+	flags.StringVarP(&execOpts.WorkDir, "workdir", "w", "", "Working directory inside the container")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+		_ = flags.MarkHidden("preserve-fds")
+	}
+
+}
+func exec(cmd *cobra.Command, args []string) error {
+	var nameOrId string
+	execOpts.Cmd = args
+	if !execOpts.Latest {
+		execOpts.Cmd = args[1:]
+		nameOrId = args[0]
+	}
+	// Validate given environment variables
+	execOpts.Envs = make(map[string]string)
+	for _, f := range envFile {
+		fileEnv, err := envLib.ParseFile(f)
+		if err != nil {
+			return err
+		}
+		execOpts.Envs = envLib.Join(execOpts.Envs, fileEnv)
+	}
+
+	cliEnv, err := envLib.ParseSlice(envInput)
+	if err != nil {
+		return errors.Wrap(err, "error parsing environment variables")
+	}
+
+	execOpts.Envs = envLib.Join(execOpts.Envs, cliEnv)
+	execOpts.Streams.OutputStream = os.Stdout
+	execOpts.Streams.ErrorStream = os.Stderr
+	if execOpts.Interactive {
+		execOpts.Streams.InputStream = bufio.NewReader(os.Stdin)
+		execOpts.Streams.AttachInput = true
+	}
+	execOpts.Streams.AttachOutput = true
+	execOpts.Streams.AttachError = true
+
+	exitCode, err := registry.ContainerEngine().ContainerExec(registry.GetContext(), nameOrId, execOpts)
+	registry.SetExitCode(exitCode)
+	return err
+}
diff --git a/cmd/podmanV2/containers/start.go b/cmd/podmanV2/containers/start.go
new file mode 100644
index 000000000..0ae2f6d50
--- /dev/null
+++ b/cmd/podmanV2/containers/start.go
@@ -0,0 +1,87 @@
+package containers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/containers/libpod/cmd/podmanV2/common"
+	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/cmd/podmanV2/utils"
+	"github.com/containers/libpod/libpod/define"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	startDescription = `Starts one or more containers.  The container name or ID can be used.`
+	startCommand     = &cobra.Command{
+		Use:     "start [flags] CONTAINER [CONTAINER...]",
+		Short:   "Start one or more containers",
+		Long:    startDescription,
+		RunE:    start,
+		PreRunE: preRunE,
+		Args:    cobra.MinimumNArgs(1),
+		Example: `podman start --latest
+  podman start 860a4b231279 5421ab43b45
+  podman start --interactive --attach imageID`,
+	}
+)
+
+var (
+	startOptions entities.ContainerStartOptions
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: startCommand,
+	})
+	flags := startCommand.Flags()
+	flags.BoolVarP(&startOptions.Attach, "attach", "a", false, "Attach container's STDOUT and STDERR")
+	flags.StringVar(&startOptions.DetachKeys, "detach-keys", common.GetDefaultDetachKeys(), "Select the key sequence for detaching a container. Format is a single character `[a-Z]` or a comma separated sequence of `ctrl-<value>`, where `<value>` is one of: `a-z`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
+	flags.BoolVarP(&startOptions.Interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
+	flags.BoolVarP(&startOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	flags.BoolVar(&startOptions.SigProxy, "sig-proxy", false, "Proxy received signals to the process (default true if attaching, false otherwise)")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+		_ = flags.MarkHidden("sig-proxy")
+	}
+
+}
+
+func start(cmd *cobra.Command, args []string) error {
+	var errs utils.OutputErrors
+	if len(args) > 1 && startOptions.Attach {
+		return errors.Errorf("you cannot start and attach multiple containers at once")
+	}
+
+	sigProxy := startOptions.SigProxy || startOptions.Attach
+	if cmd.Flag("sig-proxy").Changed {
+		sigProxy = startOptions.SigProxy
+	}
+
+	if sigProxy && !startOptions.Attach {
+		return errors.Wrapf(define.ErrInvalidArg, "you cannot use sig-proxy without --attach")
+	}
+	if startOptions.Attach {
+		startOptions.Stdin = os.Stdin
+		startOptions.Stderr = os.Stderr
+		startOptions.Stdout = os.Stdout
+	}
+
+	responses, err := registry.ContainerEngine().ContainerStart(registry.GetContext(), args, startOptions)
+	if err != nil {
+		return err
+	}
+
+	for _, r := range responses {
+		if r.Err == nil {
+			fmt.Println(r.Id)
+		} else {
+			errs = append(errs, r.Err)
+		}
+	}
+	// TODO need to understand an implement exitcodes
+	return errs.PrintErrors()
+}
diff --git a/cmd/podmanV2/main.go b/cmd/podmanV2/main.go
index 6781a7f06..fe3cd9f16 100644
--- a/cmd/podmanV2/main.go
+++ b/cmd/podmanV2/main.go
@@ -12,6 +12,7 @@ import (
 	_ "github.com/containers/libpod/cmd/podmanV2/networks"
 	_ "github.com/containers/libpod/cmd/podmanV2/pods"
 	"github.com/containers/libpod/cmd/podmanV2/registry"
+	_ "github.com/containers/libpod/cmd/podmanV2/system"
 	_ "github.com/containers/libpod/cmd/podmanV2/volumes"
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/pkg/domain/entities"
diff --git a/cmd/podmanV2/pods/inspect.go b/cmd/podmanV2/pods/inspect.go
new file mode 100644
index 000000000..9aab610f2
--- /dev/null
+++ b/cmd/podmanV2/pods/inspect.go
@@ -0,0 +1,64 @@
+package pods
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/pkg/domain/entities"
+	jsoniter "github.com/json-iterator/go"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	inspectOptions = entities.PodInspectOptions{}
+)
+
+var (
+	inspectDescription = fmt.Sprintf(`Display the configuration for a pod by name or id
+
+	By default, this will render all results in a JSON array.`)
+
+	inspectCmd = &cobra.Command{
+		Use:     "inspect [flags] POD [POD...]",
+		Short:   "Displays a pod configuration",
+		Long:    inspectDescription,
+		RunE:    inspect,
+		Example: `podman pod inspect podID`,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: inspectCmd,
+		Parent:  podCmd,
+	})
+	flags := inspectCmd.Flags()
+	flags.BoolVarP(&inspectOptions.Latest, "latest", "l", false, "Act on the latest pod podman is aware of")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+	}
+}
+
+func inspect(cmd *cobra.Command, args []string) error {
+
+	if len(args) < 1 && !inspectOptions.Latest {
+		return errors.Errorf("you must provide the name or id of a running pod")
+	}
+
+	if !inspectOptions.Latest {
+		inspectOptions.NameOrID = args[0]
+	}
+	responses, err := registry.ContainerEngine().PodInspect(context.Background(), inspectOptions)
+	if err != nil {
+		return err
+	}
+	b, err := jsoniter.MarshalIndent(responses, "", "  ")
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(b))
+	return nil
+}
diff --git a/cmd/podmanV2/system/version.go b/cmd/podmanV2/system/version.go
new file mode 100644
index 000000000..e8002056b
--- /dev/null
+++ b/cmd/podmanV2/system/version.go
@@ -0,0 +1,119 @@
+package system
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/containers/buildah/pkg/formats"
+	"github.com/containers/libpod/cmd/podmanV2/registry"
+	"github.com/containers/libpod/libpod/define"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	versionCommand = &cobra.Command{
+		Use:               "version",
+		Args:              cobra.NoArgs,
+		Short:             "Display the Podman Version Information",
+		RunE:              version,
+		PersistentPreRunE: preRunE,
+	}
+	format string
+)
+
+type versionStruct struct {
+	Client define.Version
+	Server define.Version
+}
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: versionCommand,
+	})
+	flags := versionCommand.Flags()
+	flags.StringVarP(&format, "format", "f", "", "Change the output format to JSON or a Go template")
+}
+
+func version(cmd *cobra.Command, args []string) error {
+	var (
+		v   versionStruct
+		err error
+	)
+	v.Client, err = define.GetVersion()
+	if err != nil {
+		return errors.Wrapf(err, "unable to determine version")
+	}
+	// TODO we need to discuss how to implement
+	// this more. current endpoints dont have a
+	// version endpoint.  maybe we use info?
+	//if remote {
+	//	v.Server, err = getRemoteVersion(c)
+	//	if err != nil {
+	//		return err
+	//	}
+	//} else {
+	v.Server = v.Client
+	//}
+
+	versionOutputFormat := format
+	if versionOutputFormat != "" {
+		if strings.Join(strings.Fields(versionOutputFormat), "") == "{{json.}}" {
+			versionOutputFormat = formats.JSONString
+		}
+		var out formats.Writer
+		switch versionOutputFormat {
+		case formats.JSONString:
+			out = formats.JSONStruct{Output: v}
+			return out.Out()
+		default:
+			out = formats.StdoutTemplate{Output: v, Template: versionOutputFormat}
+			err := out.Out()
+			if err != nil {
+				// On Failure, assume user is using older version of podman version --format and check client
+				out = formats.StdoutTemplate{Output: v.Client, Template: versionOutputFormat}
+				if err1 := out.Out(); err1 != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	defer w.Flush()
+
+	if registry.IsRemote() {
+		if _, err := fmt.Fprintf(w, "Client:\n"); err != nil {
+			return err
+		}
+		formatVersion(w, v.Client)
+		if _, err := fmt.Fprintf(w, "\nServer:\n"); err != nil {
+			return err
+		}
+		formatVersion(w, v.Server)
+	} else {
+		formatVersion(w, v.Client)
+	}
+	return nil
+}
+
+func formatVersion(writer io.Writer, version define.Version) {
+	fmt.Fprintf(writer, "Version:\t%s\n", version.Version)
+	fmt.Fprintf(writer, "RemoteAPI Version:\t%d\n", version.RemoteAPIVersion)
+	fmt.Fprintf(writer, "Go Version:\t%s\n", version.GoVersion)
+	if version.GitCommit != "" {
+		fmt.Fprintf(writer, "Git Commit:\t%s\n", version.GitCommit)
+	}
+	// Prints out the build time in readable format
+	if version.Built != 0 {
+		fmt.Fprintf(writer, "Built:\t%s\n", time.Unix(version.Built, 0).Format(time.ANSIC))
+	}
+
+	fmt.Fprintf(writer, "OS/Arch:\t%s\n", version.OsArch)
+}