19 files changed, 563 insertions, 127 deletions

diff --git a/pkg/api/handlers/compat/containers_attach.go b/pkg/api/handlers/compat/containers_attach.go
index 80ad52aee..012e20daf 100644
--- a/pkg/api/handlers/compat/containers_attach.go
+++ b/pkg/api/handlers/compat/containers_attach.go
@@ -10,9 +10,14 @@ import (
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
-	"k8s.io/client-go/tools/remotecommand"
 )
 
+// AttachHeader is the literal header sent for upgraded/hijacked connections for
+// attach, sourced from Docker at:
+// https://raw.githubusercontent.com/moby/moby/b95fad8e51bd064be4f4e58a996924f343846c85/api/server/router/container/container_routes.go
+// Using literally to ensure compatibility with existing clients.
+const AttachHeader = "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n"
+
 func AttachContainer(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
@@ -89,7 +94,7 @@ func AttachContainer(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 	} else if !(state == define.ContainerStateCreated || state == define.ContainerStateRunning) {
-		utils.InternalServerError(w, errors.Wrapf(define.ErrCtrStateInvalid, "can only attach to created or running containers"))
+		utils.InternalServerError(w, errors.Wrapf(define.ErrCtrStateInvalid, "can only attach to created or running containers - currently in state %s", state.String()))
 		return
 	}
 
@@ -106,10 +111,7 @@ func AttachContainer(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// This header string sourced from Docker:
-	// https://raw.githubusercontent.com/moby/moby/b95fad8e51bd064be4f4e58a996924f343846c85/api/server/router/container/container_routes.go
-	// Using literally to ensure compatability with existing clients.
-	fmt.Fprintf(connection, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n")
+	fmt.Fprintf(connection, AttachHeader)
 
 	logrus.Debugf("Hijack for attach of container %s successful", ctr.ID())
 
@@ -124,38 +126,3 @@ func AttachContainer(w http.ResponseWriter, r *http.Request) {
 
 	logrus.Debugf("Attach for container %s completed successfully", ctr.ID())
 }
-
-func ResizeContainer(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-
-	query := struct {
-		Height uint16 `schema:"h"`
-		Width  uint16 `schema:"w"`
-	}{}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		// This is not a 400, despite the fact that is should be, for
-		// compatibility reasons.
-		utils.InternalServerError(w, errors.Wrapf(err, "error parsing query options"))
-		return
-	}
-
-	name := utils.GetName(r)
-	ctr, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	newSize := remotecommand.TerminalSize{
-		Width:  query.Width,
-		Height: query.Height,
-	}
-	if err := ctr.AttachResize(newSize); err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	// This is not a 204, even though we write nothing, for compatibility
-	// reasons.
-	utils.WriteResponse(w, http.StatusOK, "")
-}
diff --git a/pkg/api/handlers/compat/containers_start.go b/pkg/api/handlers/compat/containers_start.go
index 67bd287ab..cdbc8ff76 100644
--- a/pkg/api/handlers/compat/containers_start.go
+++ b/pkg/api/handlers/compat/containers_start.go
@@ -3,11 +3,12 @@ package compat
 import (
 	"net/http"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 	"github.com/gorilla/schema"
-	"github.com/pkg/errors"
 )
 
 func StartContainer(w http.ResponseWriter, r *http.Request) {
@@ -23,8 +24,7 @@ func StartContainer(w http.ResponseWriter, r *http.Request) {
 	}
 	if len(query.DetachKeys) > 0 {
 		// TODO - start does not support adding detach keys
-		utils.BadRequest(w, "detachKeys", query.DetachKeys, errors.New("the detachKeys parameter is not supported yet"))
-		return
+		logrus.Info("the detach keys parameter is not supported on start container")
 	}
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	name := utils.GetName(r)
@@ -33,7 +33,6 @@ func StartContainer(w http.ResponseWriter, r *http.Request) {
 		utils.ContainerNotFound(w, name, err)
 		return
 	}
-
 	state, err := con.State()
 	if err != nil {
 		utils.InternalServerError(w, err)
@@ -43,7 +42,7 @@ func StartContainer(w http.ResponseWriter, r *http.Request) {
 		utils.WriteResponse(w, http.StatusNotModified, "")
 		return
 	}
-	if err := con.Start(r.Context(), false); err != nil {
+	if err := con.Start(r.Context(), len(con.PodID()) > 0); err != nil {
 		utils.InternalServerError(w, err)
 		return
 	}
diff --git a/pkg/api/handlers/compat/container_start.go b/pkg/api/handlers/compat/containers_stop.go
index d26ef2c82..d26ef2c82 100644
--- a/pkg/api/handlers/compat/container_start.go
+++ b/pkg/api/handlers/compat/containers_stop.go
diff --git a/pkg/api/handlers/compat/exec.go b/pkg/api/handlers/compat/exec.go
index ec1a8ac96..6865a3319 100644
--- a/pkg/api/handlers/compat/exec.go
+++ b/pkg/api/handlers/compat/exec.go
@@ -104,4 +104,76 @@ func ExecInspectHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	utils.WriteResponse(w, http.StatusOK, inspectOut)
+
+	// Only for the Compat API: we want to remove sessions that were
+	// stopped. This is very hacky, but should suffice for now.
+	if !utils.IsLibpodRequest(r) && inspectOut.CanRemove {
+		logrus.Infof("Pruning stale exec session %s from container %s", sessionID, sessionCtr.ID())
+		if err := sessionCtr.ExecRemove(sessionID, false); err != nil && errors.Cause(err) != define.ErrNoSuchExecSession {
+			logrus.Errorf("Error removing stale exec session %s from container %s: %v", sessionID, sessionCtr.ID(), err)
+		}
+	}
+}
+
+// ExecStartHandler runs a given exec session.
+func ExecStartHandler(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+
+	sessionID := mux.Vars(r)["id"]
+
+	// TODO: We should read/support Tty and Detach from here.
+	bodyParams := new(handlers.ExecStartConfig)
+
+	if err := json.NewDecoder(r.Body).Decode(&bodyParams); err != nil {
+		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+			errors.Wrapf(err, "failed to decode parameters for %s", r.URL.String()))
+		return
+	}
+	if bodyParams.Detach {
+		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+			errors.Errorf("Detached exec is not yet supported"))
+		return
+	}
+	// TODO: Verify TTY setting against what inspect session was made with
+
+	sessionCtr, err := runtime.GetExecSessionContainer(sessionID)
+	if err != nil {
+		utils.Error(w, fmt.Sprintf("No such exec session: %s", sessionID), http.StatusNotFound, err)
+		return
+	}
+
+	logrus.Debugf("Starting exec session %s of container %s", sessionID, sessionCtr.ID())
+
+	state, err := sessionCtr.State()
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	if state != define.ContainerStateRunning {
+		utils.Error(w, http.StatusText(http.StatusConflict), http.StatusConflict, errors.Errorf("cannot exec in a container that is not running; container %s is %s", sessionCtr.ID(), state.String()))
+		return
+	}
+
+	// Hijack the connection
+	hijacker, ok := w.(http.Hijacker)
+	if !ok {
+		utils.InternalServerError(w, errors.Errorf("unable to hijack connection"))
+		return
+	}
+
+	connection, buffer, err := hijacker.Hijack()
+	if err != nil {
+		utils.InternalServerError(w, errors.Wrapf(err, "error hijacking connection"))
+		return
+	}
+
+	fmt.Fprintf(connection, AttachHeader)
+
+	logrus.Debugf("Hijack for attach of container %s exec session %s successful", sessionCtr.ID(), sessionID)
+
+	if err := sessionCtr.ExecHTTPStartAndAttach(sessionID, connection, buffer, nil, nil, nil); err != nil {
+		logrus.Errorf("Error attaching to container %s exec session %s: %v", sessionCtr.ID(), sessionID, err)
+	}
+
+	logrus.Debugf("Attach for container %s exec session %s completed successfully", sessionCtr.ID(), sessionID)
 }
diff --git a/pkg/api/handlers/compat/ping.go b/pkg/api/handlers/compat/ping.go
index 6e77e270f..abee3d8e8 100644
--- a/pkg/api/handlers/compat/ping.go
+++ b/pkg/api/handlers/compat/ping.go
@@ -5,22 +5,22 @@ import (
 	"net/http"
 
 	"github.com/containers/buildah"
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
 )
 
 // Ping returns headers to client about the service
 //
 // This handler must always be the same for the compatibility and libpod URL trees!
 // Clients will use the Header availability to test which backend engine is in use.
+// Note: Additionally handler supports GET and HEAD methods
 func Ping(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("API-Version", handlers.DefaultApiVersion)
+	w.Header().Set("API-Version", utils.ApiVersion[utils.CompatTree][utils.CurrentApiVersion].String())
 	w.Header().Set("BuildKit-Version", "")
 	w.Header().Set("Docker-Experimental", "true")
 	w.Header().Set("Cache-Control", "no-cache")
 	w.Header().Set("Pragma", "no-cache")
 
-	// API-Version and Libpod-API-Version may not always be equal
-	w.Header().Set("Libpod-API-Version", handlers.DefaultApiVersion)
+	w.Header().Set("Libpod-API-Version", utils.ApiVersion[utils.LibpodTree][utils.CurrentApiVersion].String())
 	w.Header().Set("Libpod-Buildha-Version", buildah.Version)
 	w.WriteHeader(http.StatusOK)
 
diff --git a/pkg/api/handlers/compat/resize.go b/pkg/api/handlers/compat/resize.go
new file mode 100644
index 000000000..3ead733bc
--- /dev/null
+++ b/pkg/api/handlers/compat/resize.go
@@ -0,0 +1,68 @@
+package compat
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/gorilla/schema"
+	"github.com/pkg/errors"
+	"k8s.io/client-go/tools/remotecommand"
+)
+
+func ResizeTTY(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+
+	// /containers/{id}/resize
+	query := struct {
+		height uint16 `schema:"h"`
+		width  uint16 `schema:"w"`
+	}{
+		// override any golang type defaults
+	}
+
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+			errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+
+	sz := remotecommand.TerminalSize{
+		Width:  query.width,
+		Height: query.height,
+	}
+
+	var status int
+	name := utils.GetName(r)
+	switch {
+	case strings.Contains(r.URL.Path, "/containers/"):
+		ctnr, err := runtime.LookupContainer(name)
+		if err != nil {
+			utils.ContainerNotFound(w, name, err)
+			return
+		}
+		if err := ctnr.AttachResize(sz); err != nil {
+			utils.InternalServerError(w, errors.Wrapf(err, "cannot resize container"))
+			return
+		}
+		// This is not a 204, even though we write nothing, for compatibility
+		// reasons.
+		status = http.StatusOK
+	case strings.Contains(r.URL.Path, "/exec/"):
+		ctnr, err := runtime.GetExecSessionContainer(name)
+		if err != nil {
+			utils.SessionNotFound(w, name, err)
+			return
+		}
+		if err := ctnr.ExecResize(name, sz); err != nil {
+			utils.InternalServerError(w, errors.Wrapf(err, "cannot resize session"))
+			return
+		}
+		// This is not a 204, even though we write nothing, for compatibility
+		// reasons.
+		status = http.StatusCreated
+	}
+	utils.WriteResponse(w, status, "")
+}
diff --git a/pkg/api/handlers/compat/version.go b/pkg/api/handlers/compat/version.go
index 8786f1d5b..bfc226bb8 100644
--- a/pkg/api/handlers/compat/version.go
+++ b/pkg/api/handlers/compat/version.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/libpod/define"
-	"github.com/containers/libpod/pkg/api/handlers"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 	"github.com/containers/libpod/pkg/domain/entities"
 	docker "github.com/docker/docker/api/types"
@@ -35,34 +34,35 @@ func VersionHandler(w http.ResponseWriter, r *http.Request) {
 		Name:    "Podman Engine",
 		Version: versionInfo.Version,
 		Details: map[string]string{
-			"APIVersion":    handlers.DefaultApiVersion,
+			"APIVersion":    utils.ApiVersion[utils.LibpodTree][utils.CurrentApiVersion].String(),
 			"Arch":          goRuntime.GOARCH,
 			"BuildTime":     time.Unix(versionInfo.Built, 0).Format(time.RFC3339),
 			"Experimental":  "true",
 			"GitCommit":     versionInfo.GitCommit,
 			"GoVersion":     versionInfo.GoVersion,
 			"KernelVersion": infoData.Host.Kernel,
-			"MinAPIVersion": handlers.MinimalApiVersion,
+			"MinAPIVersion": utils.ApiVersion[utils.LibpodTree][utils.MinimalApiVersion].String(),
 			"Os":            goRuntime.GOOS,
 		},
 	}}
 
-	utils.WriteResponse(w, http.StatusOK, entities.ComponentVersion{Version: docker.Version{
-		Platform: struct {
-			Name string
-		}{
-			Name: fmt.Sprintf("%s/%s/%s-%s", goRuntime.GOOS, goRuntime.GOARCH, infoData.Host.Distribution.Distribution, infoData.Host.Distribution.Version),
-		},
-		APIVersion:    components[0].Details["APIVersion"],
-		Arch:          components[0].Details["Arch"],
-		BuildTime:     components[0].Details["BuildTime"],
-		Components:    components,
-		Experimental:  true,
-		GitCommit:     components[0].Details["GitCommit"],
-		GoVersion:     components[0].Details["GoVersion"],
-		KernelVersion: components[0].Details["KernelVersion"],
-		MinAPIVersion: components[0].Details["MinAPIVersion"],
-		Os:            components[0].Details["Os"],
-		Version:       components[0].Version,
-	}})
+	utils.WriteResponse(w, http.StatusOK, entities.ComponentVersion{
+		Version: docker.Version{
+			Platform: struct {
+				Name string
+			}{
+				Name: fmt.Sprintf("%s/%s/%s-%s", goRuntime.GOOS, goRuntime.GOARCH, infoData.Host.Distribution.Distribution, infoData.Host.Distribution.Version),
+			},
+			APIVersion:    components[0].Details["APIVersion"],
+			Arch:          components[0].Details["Arch"],
+			BuildTime:     components[0].Details["BuildTime"],
+			Components:    components,
+			Experimental:  true,
+			GitCommit:     components[0].Details["GitCommit"],
+			GoVersion:     components[0].Details["GoVersion"],
+			KernelVersion: components[0].Details["KernelVersion"],
+			MinAPIVersion: components[0].Details["MinAPIVersion"],
+			Os:            components[0].Details["Os"],
+			Version:       components[0].Version,
+		}})
 }
diff --git a/pkg/api/handlers/handler.go b/pkg/api/handlers/handler.go
deleted file mode 100644
index 2dd2c886b..000000000
--- a/pkg/api/handlers/handler.go
+++ /dev/null
@@ -1,6 +0,0 @@
-package handlers
-
-const (
-	DefaultApiVersion = "1.40" // See https://docs.docker.com/engine/api/v1.40/
-	MinimalApiVersion = "1.24"
-)
diff --git a/pkg/api/handlers/libpod/containers_create.go b/pkg/api/handlers/libpod/containers_create.go
index 40b6cacdb..71f440bce 100644
--- a/pkg/api/handlers/libpod/containers_create.go
+++ b/pkg/api/handlers/libpod/containers_create.go
@@ -5,10 +5,9 @@ import (
 	"encoding/json"
 	"net/http"
 
-	"github.com/containers/libpod/pkg/domain/entities"
-
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/containers/libpod/pkg/specgen"
 	"github.com/containers/libpod/pkg/specgen/generate"
 	"github.com/pkg/errors"
diff --git a/pkg/api/handlers/libpod/healthcheck.go b/pkg/api/handlers/libpod/healthcheck.go
index 6eb2ab0e3..0ca3574b7 100644
--- a/pkg/api/handlers/libpod/healthcheck.go
+++ b/pkg/api/handlers/libpod/healthcheck.go
@@ -4,6 +4,7 @@ import (
 	"net/http"
 
 	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 )
 
@@ -12,32 +13,27 @@ func RunHealthCheck(w http.ResponseWriter, r *http.Request) {
 	name := utils.GetName(r)
 	status, err := runtime.HealthCheck(name)
 	if err != nil {
-		if status == libpod.HealthCheckContainerNotFound {
+		if status == define.HealthCheckContainerNotFound {
 			utils.ContainerNotFound(w, name, err)
 			return
 		}
-		if status == libpod.HealthCheckNotDefined {
+		if status == define.HealthCheckNotDefined {
 			utils.Error(w, "no healthcheck defined", http.StatusConflict, err)
 			return
 		}
-		if status == libpod.HealthCheckContainerStopped {
+		if status == define.HealthCheckContainerStopped {
 			utils.Error(w, "container not running", http.StatusConflict, err)
 			return
 		}
 		utils.InternalServerError(w, err)
 		return
 	}
-	ctr, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
+	hcStatus := define.HealthCheckUnhealthy
+	if status == define.HealthCheckSuccess {
+		hcStatus = define.HealthCheckHealthy
 	}
-
-	hcLog, err := ctr.GetHealthCheckLog()
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
+	report := define.HealthCheckResults{
+		Status: hcStatus,
 	}
-
-	utils.WriteResponse(w, http.StatusOK, hcLog)
+	utils.WriteResponse(w, http.StatusOK, report)
 }
diff --git a/pkg/api/handlers/libpod/images.go b/pkg/api/handlers/libpod/images.go
index 93b4564a1..1cbcfb52c 100644
--- a/pkg/api/handlers/libpod/images.go
+++ b/pkg/api/handlers/libpod/images.go
@@ -56,13 +56,6 @@ func ImageExists(w http.ResponseWriter, r *http.Request) {
 func ImageTree(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	name := utils.GetName(r)
-
-	img, err := runtime.ImageRuntime().NewFromLocal(name)
-	if err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusNotFound, errors.Wrapf(err, "Failed to find image %s", name))
-		return
-	}
-
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
 		WhatRequires bool `schema:"whatrequires"`
@@ -74,14 +67,18 @@ func ImageTree(w http.ResponseWriter, r *http.Request) {
 			errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
-
-	tree, err := img.GenerateTree(query.WhatRequires)
+	ir := abi.ImageEngine{Libpod: runtime}
+	options := entities.ImageTreeOptions{WhatRequires: query.WhatRequires}
+	report, err := ir.Tree(r.Context(), name, options)
 	if err != nil {
+		if errors.Cause(err) == define.ErrNoSuchImage {
+			utils.Error(w, "Something went wrong.", http.StatusNotFound, errors.Wrapf(err, "Failed to find image %s", name))
+			return
+		}
 		utils.Error(w, "Server error", http.StatusInternalServerError, errors.Wrapf(err, "failed to generate image tree for %s", name))
 		return
 	}
-
-	utils.WriteResponse(w, http.StatusOK, tree)
+	utils.WriteResponse(w, http.StatusOK, report)
 }
 
 func GetImage(w http.ResponseWriter, r *http.Request) {
diff --git a/pkg/api/handlers/libpod/networks.go b/pkg/api/handlers/libpod/networks.go
index e8a92e93e..7de285e5e 100644
--- a/pkg/api/handlers/libpod/networks.go
+++ b/pkg/api/handlers/libpod/networks.go
@@ -1,39 +1,59 @@
 package libpod
 
 import (
+	"encoding/json"
 	"net/http"
 
 	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/containers/libpod/pkg/domain/infra/abi"
 	"github.com/containers/libpod/pkg/network"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 )
 
-func CreateNetwork(w http.ResponseWriter, r *http.Request) {}
-func ListNetworks(w http.ResponseWriter, r *http.Request) {
+func CreateNetwork(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	config, err := runtime.GetConfig()
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	options := entities.NetworkCreateOptions{}
+	if err := json.NewDecoder(r.Body).Decode(&options); err != nil {
+		utils.Error(w, "unable to marshall input", http.StatusInternalServerError, errors.Wrap(err, "Decode()"))
+		return
+	}
+	query := struct {
+		Name string `schema:"name"`
+	}{
+		// override any golang type defaults
+	}
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+			errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+	ic := abi.ContainerEngine{Libpod: runtime}
+	report, err := ic.NetworkCreate(r.Context(), query.Name, options)
 	if err != nil {
 		utils.InternalServerError(w, err)
 		return
 	}
-	configDir := config.Network.NetworkConfigDir
-	if len(configDir) < 1 {
-		configDir = network.CNIConfigDir
-	}
-	networks, err := network.LoadCNIConfsFromDir(configDir)
+	utils.WriteResponse(w, http.StatusOK, report)
+
+}
+func ListNetworks(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	options := entities.NetworkListOptions{}
+	ic := abi.ContainerEngine{Libpod: runtime}
+	reports, err := ic.NetworkList(r.Context(), options)
 	if err != nil {
 		utils.InternalServerError(w, err)
 		return
 	}
-	utils.WriteResponse(w, http.StatusOK, networks)
+	utils.WriteResponse(w, http.StatusOK, reports)
 }
 
 func RemoveNetwork(w http.ResponseWriter, r *http.Request) {
-	// 200 ok
-	// 404 no such
-	// 500 internal
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
 		Force bool `schema:"force"`
@@ -46,22 +66,30 @@ func RemoveNetwork(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	name := utils.GetName(r)
-	if err := network.RemoveNetwork(name); err != nil {
+
+	options := entities.NetworkRmOptions{
+		Force: query.Force,
+	}
+	ic := abi.ContainerEngine{Libpod: runtime}
+	reports, err := ic.NetworkRm(r.Context(), []string{name}, options)
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	if reports[0].Err != nil {
 		// If the network cannot be found, we return a 404.
 		if errors.Cause(err) == network.ErrNetworkNotFound {
 			utils.Error(w, "Something went wrong", http.StatusNotFound, err)
 			return
 		}
-		utils.InternalServerError(w, err)
-		return
 	}
-	utils.WriteResponse(w, http.StatusOK, "")
+	utils.WriteResponse(w, http.StatusOK, reports)
 }
 
 func InspectNetwork(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
-		Force bool `schema:"force"`
 	}{
 		// override any golang type defaults
 	}
@@ -71,7 +99,9 @@ func InspectNetwork(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	name := utils.GetName(r)
-	n, err := network.InspectNetwork(name)
+	options := entities.NetworkInspectOptions{}
+	ic := abi.ContainerEngine{Libpod: runtime}
+	reports, err := ic.NetworkInspect(r.Context(), []string{name}, options)
 	if err != nil {
 		// If the network cannot be found, we return a 404.
 		if errors.Cause(err) == network.ErrNetworkNotFound {
@@ -81,5 +111,5 @@ func InspectNetwork(w http.ResponseWriter, r *http.Request) {
 		utils.InternalServerError(w, err)
 		return
 	}
-	utils.WriteResponse(w, http.StatusOK, n)
+	utils.WriteResponse(w, http.StatusOK, reports)
 }
diff --git a/pkg/api/handlers/libpod/swagger.go b/pkg/api/handlers/libpod/swagger.go
index 46426eb6b..057fbfb41 100644
--- a/pkg/api/handlers/libpod/swagger.go
+++ b/pkg/api/handlers/libpod/swagger.go
@@ -91,6 +91,34 @@ type swagInfoResponse struct {
 	Body define.Info
 }
 
+// Network rm
+// swagger:response NetworkRmReport
+type swagNetworkRmReport struct {
+	// in:body
+	Body entities.NetworkRmReport
+}
+
+// Network inspect
+// swagger:response NetworkInspectReport
+type swagNetworkInspectReport struct {
+	// in:body
+	Body []entities.NetworkInspectReport
+}
+
+// Network list
+// swagger:response NetworkListReport
+type swagNetworkListReport struct {
+	// in:body
+	Body []entities.NetworkListReport
+}
+
+// Network create
+// swagger:response NetworkCreateReport
+type swagNetworkCreateReport struct {
+	// in:body
+	Body entities.NetworkCreateReport
+}
+
 func ServeSwagger(w http.ResponseWriter, r *http.Request) {
 	path := DefaultPodmanSwaggerSpec
 	if p, found := os.LookupEnv("PODMAN_SWAGGER_SPEC"); found {
diff --git a/pkg/api/handlers/libpod/system.go b/pkg/api/handlers/libpod/system.go
index 98e33bf10..81ed37b4a 100644
--- a/pkg/api/handlers/libpod/system.go
+++ b/pkg/api/handlers/libpod/system.go
@@ -7,6 +7,7 @@ import (
 	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/containers/libpod/pkg/domain/infra/abi"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 )
@@ -69,3 +70,25 @@ func SystemPrune(w http.ResponseWriter, r *http.Request) {
 	}
 	utils.WriteResponse(w, http.StatusOK, systemPruneReport)
 }
+
+// SystemReset Resets podman storage back to default state
+func SystemReset(w http.ResponseWriter, r *http.Request) {
+	err := r.Context().Value("runtime").(*libpod.Runtime).Reset(r.Context())
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	utils.WriteResponse(w, http.StatusOK, nil)
+}
+
+func DiskUsage(w http.ResponseWriter, r *http.Request) {
+	// Options are only used by the CLI
+	options := entities.SystemDfOptions{}
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	ic := abi.ContainerEngine{Libpod: runtime}
+	response, err := ic.SystemDf(r.Context(), options)
+	if err != nil {
+		utils.InternalServerError(w, err)
+	}
+	utils.WriteResponse(w, http.StatusOK, response)
+}
diff --git a/pkg/api/handlers/types.go b/pkg/api/handlers/types.go
index 2075d29df..d8cdd9caf 100644
--- a/pkg/api/handlers/types.go
+++ b/pkg/api/handlers/types.go
@@ -170,6 +170,11 @@ type ExecCreateResponse struct {
 	docker.IDResponse
 }
 
+type ExecStartConfig struct {
+	Detach bool `json:"Detach"`
+	Tty    bool `json:"Tty"`
+}
+
 func ImageToImageSummary(l *libpodImage.Image) (*entities.ImageSummary, error) {
 	containers, err := l.Containers()
 	if err != nil {
diff --git a/pkg/api/handlers/utils/errors.go b/pkg/api/handlers/utils/errors.go
index 3253a9be3..c17720694 100644
--- a/pkg/api/handlers/utils/errors.go
+++ b/pkg/api/handlers/utils/errors.go
@@ -63,6 +63,14 @@ func PodNotFound(w http.ResponseWriter, name string, err error) {
 	Error(w, msg, http.StatusNotFound, err)
 }
 
+func SessionNotFound(w http.ResponseWriter, name string, err error) {
+	if errors.Cause(err) != define.ErrNoSuchExecSession {
+		InternalServerError(w, err)
+	}
+	msg := fmt.Sprintf("No such exec session: %s", name)
+	Error(w, msg, http.StatusNotFound, err)
+}
+
 func ContainerNotRunning(w http.ResponseWriter, containerID string, err error) {
 	msg := fmt.Sprintf("Container %s is not running", containerID)
 	Error(w, msg, http.StatusConflict, err)
diff --git a/pkg/api/handlers/utils/handler.go b/pkg/api/handlers/utils/handler.go
index b5bd488fb..2f4a54b98 100644
--- a/pkg/api/handlers/utils/handler.go
+++ b/pkg/api/handlers/utils/handler.go
@@ -9,11 +9,55 @@ import (
 	"os"
 	"strings"
 
+	"github.com/blang/semver"
 	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
+type (
+	// VersionTree determines which API endpoint tree for version
+	VersionTree int
+	// VersionLevel determines which API level, current or something from the past
+	VersionLevel int
+)
+
+const (
+	// LibpodTree supports Libpod endpoints
+	LibpodTree = VersionTree(iota)
+	// CompatTree supports Libpod endpoints
+	CompatTree
+
+	// CurrentApiVersion announces what is the current API level
+	CurrentApiVersion = VersionLevel(iota)
+	// MinimalApiVersion announces what is the oldest API level supported
+	MinimalApiVersion
+)
+
+var (
+	// See https://docs.docker.com/engine/api/v1.40/
+	// libpod compat handlers are expected to honor docker API versions
+
+	// ApiVersion provides the current and minimal API versions for compat and libpod endpoint trees
+	// Note: GET|HEAD /_ping is never versioned and provides the API-Version and Libpod-API-Version headers to allow
+	//       clients to shop for the Version they wish to support
+	ApiVersion = map[VersionTree]map[VersionLevel]semver.Version{
+		LibpodTree: {
+			CurrentApiVersion: semver.MustParse("1.0.0"),
+			MinimalApiVersion: semver.MustParse("1.0.0"),
+		},
+		CompatTree: {
+			CurrentApiVersion: semver.MustParse("1.40.0"),
+			MinimalApiVersion: semver.MustParse("1.24.0"),
+		},
+	}
+
+	// ErrVersionNotGiven returned when version not given by client
+	ErrVersionNotGiven = errors.New("version not given in URL path")
+	// ErrVersionNotSupported returned when given version is too old
+	ErrVersionNotSupported = errors.New("given version is not supported")
+)
+
 // IsLibpodRequest returns true if the request related to a libpod endpoint
 // (e.g., /v2/libpod/...).
 func IsLibpodRequest(r *http.Request) bool {
@@ -21,6 +65,48 @@ func IsLibpodRequest(r *http.Request) bool {
 	return len(split) >= 3 && split[2] == "libpod"
 }
 
+// SupportedVersion validates that the version provided by client is included in the given condition
+// https://github.com/blang/semver#ranges provides the details for writing conditions
+// If a version is not given in URL path, ErrVersionNotGiven is returned
+func SupportedVersion(r *http.Request, condition string) (semver.Version, error) {
+	version := semver.Version{}
+	val, ok := mux.Vars(r)["version"]
+	if !ok {
+		return version, ErrVersionNotGiven
+	}
+	safeVal, err := url.PathUnescape(val)
+	if err != nil {
+		return version, errors.Wrapf(err, "unable to unescape given API version: %q", val)
+	}
+	version, err = semver.ParseTolerant(safeVal)
+	if err != nil {
+		return version, errors.Wrapf(err, "unable to parse given API version: %q from %q", safeVal, val)
+	}
+
+	inRange, err := semver.ParseRange(condition)
+	if err != nil {
+		return version, err
+	}
+
+	if inRange(version) {
+		return version, nil
+	}
+	return version, ErrVersionNotSupported
+}
+
+// SupportedVersionWithDefaults validates that the version provided by client valid is supported by server
+// minimal API version <= client path version <= maximum API version focused on the endpoint tree from URL
+func SupportedVersionWithDefaults(r *http.Request) (semver.Version, error) {
+	tree := CompatTree
+	if IsLibpodRequest(r) {
+		tree = LibpodTree
+	}
+
+	return SupportedVersion(r,
+		fmt.Sprintf(">=%s <=%s", ApiVersion[tree][MinimalApiVersion].String(),
+			ApiVersion[tree][CurrentApiVersion].String()))
+}
+
 // WriteResponse encodes the given value as JSON or string and renders it for http client
 func WriteResponse(w http.ResponseWriter, code int, value interface{}) {
 	// RFC2616 explicitly states that the following status codes "MUST NOT
diff --git a/pkg/api/handlers/utils/handler_test.go b/pkg/api/handlers/utils/handler_test.go
new file mode 100644
index 000000000..6009432b5
--- /dev/null
+++ b/pkg/api/handlers/utils/handler_test.go
@@ -0,0 +1,139 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gorilla/mux"
+)
+
+func TestSupportedVersion(t *testing.T) {
+	req, err := http.NewRequest("GET",
+		fmt.Sprintf("/v%s/libpod/testing/versions", ApiVersion[LibpodTree][CurrentApiVersion]),
+		nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req = mux.SetURLVars(req, map[string]string{"version": ApiVersion[LibpodTree][CurrentApiVersion].String()})
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := SupportedVersionWithDefaults(r)
+		switch {
+		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, err.Error())
+		case err != nil:
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		default: // all good
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, "OK")
+		}
+	})
+	handler.ServeHTTP(rr, req)
+
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Check the response body is what we expect.
+	expected := `OK`
+	if rr.Body.String() != expected {
+		t.Errorf("handler returned unexpected body: got %q want %q",
+			rr.Body.String(), expected)
+	}
+}
+
+func TestUnsupportedVersion(t *testing.T) {
+	version := "999.999.999"
+	req, err := http.NewRequest("GET",
+		fmt.Sprintf("/v%s/libpod/testing/versions", version),
+		nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req = mux.SetURLVars(req, map[string]string{"version": version})
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := SupportedVersionWithDefaults(r)
+		switch {
+		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, err.Error())
+		case err != nil:
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		default: // all good
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, "OK")
+		}
+	})
+	handler.ServeHTTP(rr, req)
+
+	if status := rr.Code; status != http.StatusBadRequest {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusBadRequest)
+	}
+
+	// Check the response body is what we expect.
+	expected := ErrVersionNotSupported.Error()
+	if rr.Body.String() != expected {
+		t.Errorf("handler returned unexpected body: got %q want %q",
+			rr.Body.String(), expected)
+	}
+}
+
+func TestEqualVersion(t *testing.T) {
+	version := "1.30.0"
+	req, err := http.NewRequest("GET",
+		fmt.Sprintf("/v%s/libpod/testing/versions", version),
+		nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req = mux.SetURLVars(req, map[string]string{"version": version})
+
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := SupportedVersion(r, "=="+version)
+		switch {
+		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, err.Error())
+		case err != nil:
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, err.Error())
+		default: // all good
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, "OK")
+		}
+	})
+	handler.ServeHTTP(rr, req)
+
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Check the response body is what we expect.
+	expected := http.StatusText(http.StatusOK)
+	if rr.Body.String() != expected {
+		t.Errorf("handler returned unexpected body: got %q want %q",
+			rr.Body.String(), expected)
+	}
+}
diff --git a/pkg/api/handlers/utils/images.go b/pkg/api/handlers/utils/images.go
index 1c67de9db..7fb31a177 100644
--- a/pkg/api/handlers/utils/images.go
+++ b/pkg/api/handlers/utils/images.go
@@ -62,7 +62,6 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 	}{
 		// This is where you can override the golang default value for one of fields
 	}
-	// TODO I think all is implemented with a filter?
 
 	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
 		return nil, err
@@ -71,6 +70,10 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 	if _, found := r.URL.Query()["digests"]; found && query.Digests {
 		UnSupportedParameter("digests")
 	}
+	var (
+		images []*image.Image
+		err    error
+	)
 
 	if len(query.Filters) > 0 {
 		for k, v := range query.Filters {
@@ -78,11 +81,33 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 				filters = append(filters, fmt.Sprintf("%s=%s", k, val))
 			}
 		}
-		return runtime.ImageRuntime().GetImagesWithFilters(filters)
+		images, err = runtime.ImageRuntime().GetImagesWithFilters(filters)
+		if err != nil {
+			return images, err
+		}
 	} else {
-		return runtime.ImageRuntime().GetImages()
+		images, err = runtime.ImageRuntime().GetImages()
+		if err != nil {
+			return images, err
+		}
 	}
-
+	if query.All {
+		return images, nil
+	}
+	var returnImages []*image.Image
+	for _, img := range images {
+		if len(img.Names()) == 0 {
+			parent, err := img.IsParent(r.Context())
+			if err != nil {
+				return nil, err
+			}
+			if parent {
+				continue
+			}
+		}
+		returnImages = append(returnImages, img)
+	}
+	return returnImages, nil
 }
 
 func GetImage(r *http.Request, name string) (*image.Image, error) {