Refactor handler packages

To help with packaging, the handlers in pkg/api/handlers are now found
in pkg/api/handler/compat.

Signed-off-by: Jhon Honce <jhonce@redhat.com>

46 files changed, 740 insertions, 752 deletions

diff --git a/pkg/api/handlers/compat/container_start.go b/pkg/api/handlers/compat/container_start.go
new file mode 100644
index 000000000..d26ef2c82
--- /dev/null
+++ b/pkg/api/handlers/compat/container_start.go
@@ -0,0 +1,60 @@
+package compat
+
+import (
+	"net/http"
+
+	"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 StopContainer(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+
+	// /{version}/containers/(name)/stop
+	query := struct {
+		Timeout int `schema:"t"`
+	}{
+		// 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
+	}
+
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	state, err := con.State()
+	if err != nil {
+		utils.InternalServerError(w, errors.Wrapf(err, "unable to get state for Container %s", name))
+		return
+	}
+	// If the Container is stopped already, send a 304
+	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
+		utils.WriteResponse(w, http.StatusNotModified, "")
+		return
+	}
+
+	var stopError error
+	if query.Timeout > 0 {
+		stopError = con.StopWithTimeout(uint(query.Timeout))
+	} else {
+		stopError = con.Stop()
+	}
+	if stopError != nil {
+		utils.InternalServerError(w, errors.Wrapf(stopError, "failed to stop %s", name))
+		return
+	}
+
+	// Success
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}
diff --git a/pkg/api/handlers/generic/containers.go b/pkg/api/handlers/compat/containers.go
index b8460702c..1298e7fa4 100644
--- a/pkg/api/handlers/generic/containers.go
+++ b/pkg/api/handlers/compat/containers.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"encoding/binary"
@@ -7,9 +7,11 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"syscall"
 	"time"
 
 	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/libpod/define"
 	"github.com/containers/libpod/libpod/logs"
 	"github.com/containers/libpod/pkg/api/handlers"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
@@ -34,12 +36,26 @@ func RemoveContainer(w http.ResponseWriter, r *http.Request) {
 			errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
 		return
 	}
-	if query.Link {
+
+	if query.Link && !utils.IsLibpodRequest(r) {
 		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
 			utils.ErrLinkNotSupport)
 		return
 	}
-	utils.RemoveContainer(w, r, query.Force, query.Vols)
+
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	if err := runtime.RemoveContainer(r.Context(), con, query.Force, query.Vols); err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	utils.WriteResponse(w, http.StatusNoContent, "")
 }
 
 func ListContainers(w http.ResponseWriter, r *http.Request) {
@@ -126,18 +142,51 @@ func GetContainer(w http.ResponseWriter, r *http.Request) {
 
 func KillContainer(w http.ResponseWriter, r *http.Request) {
 	// /{version}/containers/(name)/kill
-	con, err := utils.KillContainer(w, r)
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	query := struct {
+		Signal syscall.Signal `schema:"signal"`
+	}{
+		Signal: syscall.SIGKILL,
+	}
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	state, err := con.State()
 	if err != nil {
+		utils.InternalServerError(w, err)
 		return
 	}
-	// the kill behavior for docker differs from podman in that they appear to wait
-	// for the Container to croak so the exit code is accurate immediately after the
-	// kill is sent.  libpod does not.  but we can add a wait here only for the docker
-	// side of things and mimic that behavior
-	if _, err = con.Wait(); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "failed to wait for Container %s", con.ID()))
+
+	// If the Container is stopped already, send a 409
+	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
+		utils.Error(w, fmt.Sprintf("Container %s is not running", name), http.StatusConflict, errors.New(fmt.Sprintf("Cannot kill Container %s, it is not running", name)))
 		return
 	}
+
+	err = con.Kill(uint(query.Signal))
+	if err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "unable to kill Container %s", name))
+	}
+
+	if utils.IsLibpodRequest(r) {
+		// the kill behavior for docker differs from podman in that they appear to wait
+		// for the Container to croak so the exit code is accurate immediately after the
+		// kill is sent.  libpod does not.  but we can add a wait here only for the docker
+		// side of things and mimic that behavior
+		if _, err = con.Wait(); err != nil {
+			utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "failed to wait for Container %s", con.ID()))
+			return
+		}
+	}
 	// Success
 	utils.WriteResponse(w, http.StatusNoContent, "")
 }
diff --git a/pkg/api/handlers/containers_attach.go b/pkg/api/handlers/compat/containers_attach.go
index 5a799a20c..da7b5bb0c 100644
--- a/pkg/api/handlers/containers_attach.go
+++ b/pkg/api/handlers/compat/containers_attach.go
@@ -1,4 +1,4 @@
-package handlers
+package compat
 
 import (
 	"net/http"
diff --git a/pkg/api/handlers/generic/containers_create.go b/pkg/api/handlers/compat/containers_create.go
index 7e542752f..6b8440fc2 100644
--- a/pkg/api/handlers/generic/containers_create.go
+++ b/pkg/api/handlers/compat/containers_create.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"encoding/json"
diff --git a/pkg/api/handlers/compat/containers_pause.go b/pkg/api/handlers/compat/containers_pause.go
new file mode 100644
index 000000000..060bdbaeb
--- /dev/null
+++ b/pkg/api/handlers/compat/containers_pause.go
@@ -0,0 +1,28 @@
+package compat
+
+import (
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+)
+
+func PauseContainer(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+
+	// /{version}/containers/(name)/pause
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	// the api does not error if the Container is already paused, so just into it
+	if err := con.Pause(); err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	// Success
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}
diff --git a/pkg/api/handlers/compat/containers_prune.go b/pkg/api/handlers/compat/containers_prune.go
new file mode 100644
index 000000000..a56c3903d
--- /dev/null
+++ b/pkg/api/handlers/compat/containers_prune.go
@@ -0,0 +1,64 @@
+package compat
+
+import (
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/docker/docker/api/types"
+	"github.com/gorilla/schema"
+	"github.com/pkg/errors"
+)
+
+func PruneContainers(w http.ResponseWriter, r *http.Request) {
+	var (
+		delContainers []string
+		space         int64
+	)
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+
+	query := struct {
+		Filters map[string][]string `schema:"filters"`
+	}{}
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+
+	filterFuncs, err := utils.GenerateFilterFuncsFromMap(runtime, query.Filters)
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	prunedContainers, pruneErrors, err := runtime.PruneContainers(filterFuncs)
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+
+	// Libpod response differs
+	if utils.IsLibpodRequest(r) {
+		var response []handlers.LibpodContainersPruneReport
+		for ctrID, size := range prunedContainers {
+			response = append(response, handlers.LibpodContainersPruneReport{ID: ctrID, SpaceReclaimed: size})
+		}
+		for ctrID, err := range pruneErrors {
+			response = append(response, handlers.LibpodContainersPruneReport{ID: ctrID, PruneError: err.Error()})
+		}
+		utils.WriteResponse(w, http.StatusOK, response)
+		return
+	}
+	for ctrID, size := range prunedContainers {
+		if pruneErrors[ctrID] == nil {
+			space += size
+			delContainers = append(delContainers, ctrID)
+		}
+	}
+	report := types.ContainersPruneReport{
+		ContainersDeleted: delContainers,
+		SpaceReclaimed:    uint64(space),
+	}
+	utils.WriteResponse(w, http.StatusOK, report)
+}
diff --git a/pkg/api/handlers/compat/containers_restart.go b/pkg/api/handlers/compat/containers_restart.go
new file mode 100644
index 000000000..5b8fafaa4
--- /dev/null
+++ b/pkg/api/handlers/compat/containers_restart.go
@@ -0,0 +1,61 @@
+package compat
+
+import (
+	"fmt"
+	"net/http"
+
+	"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 RestartContainer(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	// /{version}/containers/(name)/restart
+	query := struct {
+		Timeout int `schema:"t"`
+	}{
+		// Override golang default values for types
+	}
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.BadRequest(w, "url", r.URL.String(), errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	state, err := con.State()
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+
+	// FIXME: This is not in the swagger.yml...
+	// If the Container is stopped already, send a 409
+	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
+		msg := fmt.Sprintf("Container %s is not running", name)
+		utils.Error(w, msg, http.StatusConflict, errors.New(msg))
+		return
+	}
+
+	timeout := con.StopTimeout()
+	if _, found := r.URL.Query()["t"]; found {
+		timeout = uint(query.Timeout)
+	}
+
+	if err := con.RestartWithTimeout(r.Context(), timeout); err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+
+	// Success
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}
diff --git a/pkg/api/handlers/compat/containers_start.go b/pkg/api/handlers/compat/containers_start.go
new file mode 100644
index 000000000..67bd287ab
--- /dev/null
+++ b/pkg/api/handlers/compat/containers_start.go
@@ -0,0 +1,51 @@
+package compat
+
+import (
+	"net/http"
+
+	"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) {
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	query := struct {
+		DetachKeys string `schema:"detachKeys"`
+	}{
+		// Override golang default values for types
+	}
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.BadRequest(w, "url", r.URL.String(), err)
+		return
+	}
+	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
+	}
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	state, err := con.State()
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	if state == define.ContainerStateRunning {
+		utils.WriteResponse(w, http.StatusNotModified, "")
+		return
+	}
+	if err := con.Start(r.Context(), false); err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}
diff --git a/pkg/api/handlers/generic/containers_stats.go b/pkg/api/handlers/compat/containers_stats.go
index 977979741..53ad0a632 100644
--- a/pkg/api/handlers/generic/containers_stats.go
+++ b/pkg/api/handlers/compat/containers_stats.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"encoding/json"
diff --git a/pkg/api/handlers/containers_top.go b/pkg/api/handlers/compat/containers_top.go
index 06d5dd653..202be55d1 100644
--- a/pkg/api/handlers/containers_top.go
+++ b/pkg/api/handlers/compat/containers_top.go
@@ -1,10 +1,11 @@
-package handlers
+package compat
 
 import (
 	"net/http"
 	"strings"
 
 	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
@@ -42,7 +43,7 @@ func TopContainer(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var body = ContainerTopOKBody{}
+	var body = handlers.ContainerTopOKBody{}
 	if len(output) > 0 {
 		body.Titles = strings.Split(output[0], "\t")
 		for _, line := range output[1:] {
diff --git a/pkg/api/handlers/compat/containers_unpause.go b/pkg/api/handlers/compat/containers_unpause.go
new file mode 100644
index 000000000..adabdeaea
--- /dev/null
+++ b/pkg/api/handlers/compat/containers_unpause.go
@@ -0,0 +1,28 @@
+package compat
+
+import (
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+)
+
+func UnpauseContainer(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+
+	// /{version}/containers/(name)/unpause
+	name := utils.GetName(r)
+	con, err := runtime.LookupContainer(name)
+	if err != nil {
+		utils.ContainerNotFound(w, name, err)
+		return
+	}
+
+	if err := con.Unpause(); err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+
+	// Success
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}
diff --git a/pkg/api/handlers/events.go b/pkg/api/handlers/compat/events.go
index 22dad9923..0f72ef328 100644
--- a/pkg/api/handlers/events.go
+++ b/pkg/api/handlers/compat/events.go
@@ -1,12 +1,15 @@
-package handlers
+package compat
 
 import (
 	"encoding/json"
 	"fmt"
 	"net/http"
 
+	"github.com/containers/libpod/libpod"
 	"github.com/containers/libpod/libpod/events"
+	"github.com/containers/libpod/pkg/api/handlers"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
@@ -15,13 +18,16 @@ func GetEvents(w http.ResponseWriter, r *http.Request) {
 	var (
 		fromStart   bool
 		eventsError error
+		decoder     = r.Context().Value("decoder").(*schema.Decoder)
+		runtime     = r.Context().Value("runtime").(*libpod.Runtime)
 	)
+
 	query := struct {
 		Since   string              `schema:"since"`
 		Until   string              `schema:"until"`
 		Filters map[string][]string `schema:"filters"`
 	}{}
-	if err := decodeQuery(r, &query); err != nil {
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
 		utils.Error(w, "Failed to parse parameters", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
 	}
 
@@ -38,19 +44,20 @@ func GetEvents(w http.ResponseWriter, r *http.Request) {
 	eventChannel := make(chan *events.Event)
 	go func() {
 		readOpts := events.ReadOptions{FromStart: fromStart, Stream: true, Filters: libpodFilters, EventChannel: eventChannel, Since: query.Since, Until: query.Until}
-		eventsError = getRuntime(r).Events(readOpts)
+		eventsError = runtime.Events(readOpts)
 	}()
 	if eventsError != nil {
 		utils.InternalServerError(w, eventsError)
 		return
 	}
+
+	coder := json.NewEncoder(w)
+	coder.SetEscapeHTML(true)
+
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)
 	for event := range eventChannel {
-		e := EventToApiEvent(event)
-		//utils.WriteJSON(w, http.StatusOK, e)
-		coder := json.NewEncoder(w)
-		coder.SetEscapeHTML(true)
+		e := handlers.EventToApiEvent(event)
 		if err := coder.Encode(e); err != nil {
 			logrus.Errorf("unable to write json: %q", err)
 		}
diff --git a/pkg/api/handlers/generic/images.go b/pkg/api/handlers/compat/images.go
index 078896834..b18687bf9 100644
--- a/pkg/api/handlers/generic/images.go
+++ b/pkg/api/handlers/compat/images.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"encoding/json"
@@ -198,7 +198,7 @@ func CreateImageFromSrc(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 		source = f.Name()
-		if err := handlers.SaveFromBody(f, r); err != nil {
+		if err := SaveFromBody(f, r); err != nil {
 			utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrap(err, "failed to write temporary file"))
 		}
 	}
@@ -286,7 +286,7 @@ func GetImage(w http.ResponseWriter, r *http.Request) {
 	// 404 no such
 	// 500 internal
 	name := utils.GetName(r)
-	newImage, err := handlers.GetImage(r, name)
+	newImage, err := utils.GetImage(r, name)
 	if err != nil {
 		utils.Error(w, "Something went wrong.", http.StatusNotFound, errors.Wrapf(err, "Failed to find image %s", name))
 		return
@@ -344,7 +344,7 @@ func LoadImages(w http.ResponseWriter, r *http.Request) {
 		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrap(err, "failed to create tempfile"))
 		return
 	}
-	if err := handlers.SaveFromBody(f, r); err != nil {
+	if err := SaveFromBody(f, r); err != nil {
 		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrap(err, "failed to write temporary file"))
 		return
 	}
diff --git a/pkg/api/handlers/images_build.go b/pkg/api/handlers/compat/images_build.go
index d969e3a47..e208e6ddc 100644
--- a/pkg/api/handlers/images_build.go
+++ b/pkg/api/handlers/compat/images_build.go
@@ -1,4 +1,4 @@
-package handlers
+package compat
 
 import (
 	"bytes"
@@ -15,12 +15,15 @@ import (
 
 	"github.com/containers/buildah"
 	"github.com/containers/buildah/imagebuildah"
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers"
 	"github.com/containers/libpod/pkg/api/handlers/utils"
 	"github.com/containers/storage/pkg/archive"
+	"github.com/gorilla/schema"
 )
 
 func BuildImage(w http.ResponseWriter, r *http.Request) {
-	authConfigs := map[string]AuthConfig{}
+	authConfigs := map[string]handlers.AuthConfig{}
 	if hdr, found := r.Header["X-Registry-Config"]; found && len(hdr) > 0 {
 		authConfigsJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(hdr[0]))
 		if json.NewDecoder(authConfigsJSON).Decode(&authConfigs) != nil {
@@ -96,8 +99,8 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		Outputs:     "",
 		Registry:    "docker.io",
 	}
-
-	if err := decodeQuery(r, &query); err != nil {
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
 		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest, err)
 		return
 	}
@@ -219,7 +222,8 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		Devices:                 nil,
 	}
 
-	id, _, err := getRuntime(r).Build(r.Context(), buildOptions, query.Dockerfile)
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	id, _, err := runtime.Build(r.Context(), buildOptions, query.Dockerfile)
 	if err != nil {
 		utils.InternalServerError(w, err)
 	}
diff --git a/pkg/api/handlers/compat/images_history.go b/pkg/api/handlers/compat/images_history.go
new file mode 100644
index 000000000..04304caa4
--- /dev/null
+++ b/pkg/api/handlers/compat/images_history.go
@@ -0,0 +1,40 @@
+package compat
+
+import (
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/pkg/errors"
+)
+
+func HistoryImage(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	name := utils.GetName(r)
+	var allHistory []handlers.HistoryResponse
+
+	newImage, 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
+
+	}
+	history, err := newImage.History(r.Context())
+	if err != nil {
+		utils.InternalServerError(w, err)
+		return
+	}
+	for _, h := range history {
+		l := handlers.HistoryResponse{
+			ID:        h.ID,
+			Created:   h.Created.UnixNano(),
+			CreatedBy: h.CreatedBy,
+			Tags:      h.Tags,
+			Size:      h.Size,
+			Comment:   h.Comment,
+		}
+		allHistory = append(allHistory, l)
+	}
+	utils.WriteResponse(w, http.StatusOK, allHistory)
+}
diff --git a/pkg/api/handlers/compat/images_remove.go b/pkg/api/handlers/compat/images_remove.go
new file mode 100644
index 000000000..3d346543e
--- /dev/null
+++ b/pkg/api/handlers/compat/images_remove.go
@@ -0,0 +1,52 @@
+package compat
+
+import (
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/gorilla/schema"
+	"github.com/pkg/errors"
+)
+
+func RemoveImage(w http.ResponseWriter, r *http.Request) {
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+
+	query := struct {
+		Force   bool `schema:"force"`
+		NoPrune bool `schema:"noprune"`
+	}{
+		// This is where you can override the golang default value for one of fields
+	}
+
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+	if _, found := r.URL.Query()["noprune"]; found {
+		if query.NoPrune {
+			utils.UnSupportedParameter("noprune")
+		}
+	}
+	name := utils.GetName(r)
+	newImage, err := runtime.ImageRuntime().NewFromLocal(name)
+	if err != nil {
+		utils.ImageNotFound(w, name, errors.Wrapf(err, "Failed to find image %s", name))
+		return
+	}
+
+	_, err = runtime.RemoveImage(r.Context(), newImage, query.Force)
+	if err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, err)
+		return
+	}
+	// TODO
+	// This will need to be fixed for proper response, like Deleted: and Untagged:
+	m := make(map[string]string)
+	m["Deleted"] = newImage.ID()
+	foo := []map[string]string{}
+	foo = append(foo, m)
+	utils.WriteResponse(w, http.StatusOK, foo)
+
+}
diff --git a/pkg/api/handlers/compat/images_save.go b/pkg/api/handlers/compat/images_save.go
new file mode 100644
index 000000000..b39c719a0
--- /dev/null
+++ b/pkg/api/handlers/compat/images_save.go
@@ -0,0 +1,14 @@
+package compat
+
+import (
+	"io"
+	"net/http"
+	"os"
+)
+
+func SaveFromBody(f *os.File, r *http.Request) error { // nolint
+	if _, err := io.Copy(f, r.Body); err != nil {
+		return err
+	}
+	return f.Close()
+}
diff --git a/pkg/api/handlers/compat/images_search.go b/pkg/api/handlers/compat/images_search.go
new file mode 100644
index 000000000..7283b22c4
--- /dev/null
+++ b/pkg/api/handlers/compat/images_search.go
@@ -0,0 +1,66 @@
+package compat
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/containers/image/v5/types"
+	"github.com/containers/libpod/libpod/image"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/gorilla/schema"
+	"github.com/pkg/errors"
+)
+
+func SearchImages(w http.ResponseWriter, r *http.Request) {
+	decoder := r.Context().Value("decoder").(*schema.Decoder)
+	query := struct {
+		Term    string              `json:"term"`
+		Limit   int                 `json:"limit"`
+		Filters map[string][]string `json:"filters"`
+	}{
+		// This is where you can override the golang default value for one of fields
+	}
+
+	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
+		return
+	}
+
+	filter := image.SearchFilter{}
+	if len(query.Filters) > 0 {
+		if len(query.Filters["stars"]) > 0 {
+			stars, err := strconv.Atoi(query.Filters["stars"][0])
+			if err != nil {
+				utils.InternalServerError(w, err)
+				return
+			}
+			filter.Stars = stars
+		}
+		if len(query.Filters["is-official"]) > 0 {
+			isOfficial, err := strconv.ParseBool(query.Filters["is-official"][0])
+			if err != nil {
+				utils.InternalServerError(w, err)
+				return
+			}
+			filter.IsOfficial = types.NewOptionalBool(isOfficial)
+		}
+		if len(query.Filters["is-automated"]) > 0 {
+			isAutomated, err := strconv.ParseBool(query.Filters["is-automated"][0])
+			if err != nil {
+				utils.InternalServerError(w, err)
+				return
+			}
+			filter.IsAutomated = types.NewOptionalBool(isAutomated)
+		}
+	}
+	options := image.SearchOptions{
+		Filter: filter,
+		Limit:  query.Limit,
+	}
+	results, err := image.SearchImages(query.Term, options)
+	if err != nil {
+		utils.BadRequest(w, "term", query.Term, err)
+		return
+	}
+	utils.WriteResponse(w, http.StatusOK, results)
+}
diff --git a/pkg/api/handlers/compat/images_tag.go b/pkg/api/handlers/compat/images_tag.go
new file mode 100644
index 000000000..722be5653
--- /dev/null
+++ b/pkg/api/handlers/compat/images_tag.go
@@ -0,0 +1,37 @@
+package compat
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/api/handlers/utils"
+	"github.com/pkg/errors"
+)
+
+func TagImage(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+
+	// /v1.xx/images/(name)/tag
+	name := utils.GetName(r)
+	newImage, err := runtime.ImageRuntime().NewFromLocal(name)
+	if err != nil {
+		utils.ImageNotFound(w, name, errors.Wrapf(err, "Failed to find image %s", name))
+		return
+	}
+	tag := "latest"
+	if len(r.Form.Get("tag")) > 0 {
+		tag = r.Form.Get("tag")
+	}
+	if len(r.Form.Get("repo")) < 1 {
+		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.New("repo parameter is required to tag an image"))
+		return
+	}
+	repo := r.Form.Get("repo")
+	tagName := fmt.Sprintf("%s:%s", repo, tag)
+	if err := newImage.TagImage(tagName); err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, err)
+		return
+	}
+	utils.WriteResponse(w, http.StatusCreated, "")
+}
diff --git a/pkg/api/handlers/generic/info.go b/pkg/api/handlers/compat/info.go
index c9e79233d..30b49948d 100644
--- a/pkg/api/handlers/generic/info.go
+++ b/pkg/api/handlers/compat/info.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"fmt"
diff --git a/pkg/api/handlers/ping.go b/pkg/api/handlers/compat/ping.go
index d41da60f3..6e77e270f 100644
--- a/pkg/api/handlers/ping.go
+++ b/pkg/api/handlers/compat/ping.go
@@ -1,10 +1,11 @@
-package handlers
+package compat
 
 import (
 	"fmt"
 	"net/http"
 
 	"github.com/containers/buildah"
+	"github.com/containers/libpod/pkg/api/handlers"
 )
 
 // Ping returns headers to client about the service
@@ -12,14 +13,14 @@ import (
 // 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.
 func Ping(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("API-Version", DefaultApiVersion)
+	w.Header().Set("API-Version", handlers.DefaultApiVersion)
 	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", DefaultApiVersion)
+	w.Header().Set("Libpod-API-Version", handlers.DefaultApiVersion)
 	w.Header().Set("Libpod-Buildha-Version", buildah.Version)
 	w.WriteHeader(http.StatusOK)
 
diff --git a/pkg/api/handlers/generic/swagger.go b/pkg/api/handlers/compat/swagger.go
index c9c9610bb..cbd8e61fb 100644
--- a/pkg/api/handlers/generic/swagger.go
+++ b/pkg/api/handlers/compat/swagger.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"github.com/containers/libpod/pkg/api/handlers/utils"
diff --git a/pkg/api/handlers/generic/system.go b/pkg/api/handlers/compat/system.go
index edf1f8522..47e187ba1 100644
--- a/pkg/api/handlers/generic/system.go
+++ b/pkg/api/handlers/compat/system.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"net/http"
diff --git a/pkg/api/handlers/generic/types.go b/pkg/api/handlers/compat/types.go
index f068ac011..b8d06760f 100644
--- a/pkg/api/handlers/generic/types.go
+++ b/pkg/api/handlers/compat/types.go
@@ -1,4 +1,4 @@
-package generic
+package compat
 
 import (
 	"time"
diff --git a/pkg/api/handlers/unsupported.go b/pkg/api/handlers/compat/unsupported.go
index 956d31f8b..d9c3c3f49 100644
--- a/pkg/api/handlers/unsupported.go
+++ b/pkg/api/handlers/compat/unsupported.go
@@ -1,4 +1,4 @@
-package handlers
+package compat
 
 import (
 	"fmt"
diff --git a/pkg/api/handlers/version.go b/pkg/api/handlers/compat/version.go
index 94166952c..c7f7917ac 100644
--- a/pkg/api/handlers/version.go
+++ b/pkg/api/handlers/compat/version.go
@@ -1,4 +1,4 @@
-package handlers
+package compat
 
 import (
 	"fmt"
@@ -8,16 +8,12 @@ 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"
 	docker "github.com/docker/docker/api/types"
 	"github.com/pkg/errors"
 )
 
-const (
-	DefaultApiVersion = "1.40" // See https://docs.docker.com/engine/api/v1.40/
-	MinimalApiVersion = "1.24"
-)
-
 func VersionHandler(w http.ResponseWriter, r *http.Request) {
 	// 200 ok
 	// 500 internal
@@ -40,19 +36,19 @@ func VersionHandler(w http.ResponseWriter, r *http.Request) {
 		Name:    "Podman Engine",
 		Version: versionInfo.Version,
 		Details: map[string]string{
-			"APIVersion":    DefaultApiVersion,
+			"APIVersion":    handlers.DefaultApiVersion,
 			"Arch":          goRuntime.GOARCH,
 			"BuildTime":     time.Unix(versionInfo.Built, 0).Format(time.RFC3339),
 			"Experimental":  "true",
 			"GitCommit":     versionInfo.GitCommit,
 			"GoVersion":     versionInfo.GoVersion,
 			"KernelVersion": hostInfo["kernel"].(string),
-			"MinAPIVersion": MinimalApiVersion,
+			"MinAPIVersion": handlers.MinimalApiVersion,
 			"Os":            goRuntime.GOOS,
 		},
 	}}
 
-	utils.WriteResponse(w, http.StatusOK, Version{Version: docker.Version{
+	utils.WriteResponse(w, http.StatusOK, handlers.Version{Version: docker.Version{
 		Platform: struct {
 			Name string
 		}{
diff --git a/pkg/api/handlers/containers.go b/pkg/api/handlers/containers.go
deleted file mode 100644
index 1256256fd..000000000
--- a/pkg/api/handlers/containers.go
+++ /dev/null
@@ -1,243 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/containers/libpod/libpod"
-	"github.com/containers/libpod/libpod/define"
-	"github.com/containers/libpod/pkg/api/handlers/utils"
-	"github.com/docker/docker/api/types"
-	"github.com/gorilla/schema"
-	"github.com/pkg/errors"
-)
-
-func StopContainer(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-
-	// /{version}/containers/(name)/stop
-	query := struct {
-		Timeout int `schema:"t"`
-	}{
-		// 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
-	}
-
-	name := utils.GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	state, err := con.State()
-	if err != nil {
-		utils.InternalServerError(w, errors.Wrapf(err, "unable to get state for Container %s", name))
-		return
-	}
-	// If the Container is stopped already, send a 304
-	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
-		utils.WriteResponse(w, http.StatusNotModified, "")
-		return
-	}
-
-	var stopError error
-	if query.Timeout > 0 {
-		stopError = con.StopWithTimeout(uint(query.Timeout))
-	} else {
-		stopError = con.Stop()
-	}
-	if stopError != nil {
-		utils.InternalServerError(w, errors.Wrapf(stopError, "failed to stop %s", name))
-		return
-	}
-
-	// Success
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
-func UnpauseContainer(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-
-	// /{version}/containers/(name)/unpause
-	name := utils.GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	if err := con.Unpause(); err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-
-	// Success
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
-func PauseContainer(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-
-	// /{version}/containers/(name)/pause
-	name := utils.GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	// the api does not error if the Container is already paused, so just into it
-	if err := con.Pause(); err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	// Success
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
-func StartContainer(w http.ResponseWriter, r *http.Request) {
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	query := struct {
-		DetachKeys string `schema:"detachKeys"`
-	}{
-		// Override golang default values for types
-	}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return
-	}
-	if len(query.DetachKeys) > 0 {
-		// TODO - start does not support adding detach keys
-		utils.Error(w, "Something went wrong", http.StatusBadRequest, errors.New("the detachKeys parameter is not supported yet"))
-		return
-	}
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	name := utils.GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	state, err := con.State()
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	if state == define.ContainerStateRunning {
-		utils.WriteResponse(w, http.StatusNotModified, "")
-		return
-	}
-	if err := con.Start(r.Context(), false); err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
-func RestartContainer(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	// /{version}/containers/(name)/restart
-	query := struct {
-		Timeout int `schema:"t"`
-	}{
-		// Override golang default values for types
-	}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return
-	}
-
-	name := utils.GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		utils.ContainerNotFound(w, name, err)
-		return
-	}
-
-	state, err := con.State()
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-
-	// FIXME: This is not in the swagger.yml...
-	// If the Container is stopped already, send a 409
-	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
-		msg := fmt.Sprintf("Container %s is not running", name)
-		utils.Error(w, msg, http.StatusConflict, errors.New(msg))
-		return
-	}
-
-	timeout := con.StopTimeout()
-	if _, found := r.URL.Query()["t"]; found {
-		timeout = uint(query.Timeout)
-	}
-
-	if err := con.RestartWithTimeout(r.Context(), timeout); err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-
-	// Success
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
-func PruneContainers(w http.ResponseWriter, r *http.Request) {
-	var (
-		delContainers []string
-		space         int64
-	)
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-
-	query := struct {
-		Filters map[string][]string `schema:"filter"`
-	}{}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return
-	}
-
-	filterFuncs, err := utils.GenerateFilterFuncsFromMap(runtime, query.Filters)
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	prunedContainers, pruneErrors, err := runtime.PruneContainers(filterFuncs)
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-
-	// Libpod response differs
-	if utils.IsLibpodRequest(r) {
-		var response []LibpodContainersPruneReport
-		for ctrID, size := range prunedContainers {
-			response = append(response, LibpodContainersPruneReport{ID: ctrID, SpaceReclaimed: size})
-		}
-		for ctrID, err := range pruneErrors {
-			response = append(response, LibpodContainersPruneReport{ID: ctrID, PruneError: err.Error()})
-		}
-		utils.WriteResponse(w, http.StatusOK, response)
-		return
-	}
-	for ctrID, size := range prunedContainers {
-		if pruneErrors[ctrID] == nil {
-			space += size
-			delContainers = append(delContainers, ctrID)
-		}
-	}
-	report := types.ContainersPruneReport{
-		ContainersDeleted: delContainers,
-		SpaceReclaimed:    uint64(space),
-	}
-	utils.WriteResponse(w, http.StatusOK, report)
-}
diff --git a/pkg/api/handlers/exec.go b/pkg/api/handlers/exec.go
deleted file mode 100644
index 8a7b2ae26..000000000
--- a/pkg/api/handlers/exec.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"github.com/containers/libpod/libpod/define"
-	"github.com/containers/libpod/pkg/api/handlers/utils"
-)
-
-func CreateExec(w http.ResponseWriter, r *http.Request) {
-	utils.Error(w, "function not implemented", http.StatusInternalServerError, define.ErrNotImplemented)
-}
-
-func StartExec(w http.ResponseWriter, r *http.Request) {
-	utils.Error(w, "function not implemented", http.StatusInternalServerError, define.ErrNotImplemented)
-}
-
-func ResizeExec(w http.ResponseWriter, r *http.Request) {
-	utils.Error(w, "function not implemented", http.StatusInternalServerError, define.ErrNotImplemented)
-
-}
-
-func InspectExec(w http.ResponseWriter, r *http.Request) {
-	utils.Error(w, "function not implemented", http.StatusInternalServerError, define.ErrNotImplemented)
-}
diff --git a/pkg/api/handlers/handler.go b/pkg/api/handlers/handler.go
index 231c11f23..2dd2c886b 100644
--- a/pkg/api/handlers/handler.go
+++ b/pkg/api/handlers/handler.go
@@ -1,38 +1,6 @@
 package handlers
 
-import (
-	"net/http"
-
-	"github.com/containers/libpod/libpod"
-	"github.com/gorilla/schema"
-	"github.com/pkg/errors"
+const (
+	DefaultApiVersion = "1.40" // See https://docs.docker.com/engine/api/v1.40/
+	MinimalApiVersion = "1.24"
 )
-
-// Convenience routines to reduce boiler plate in handlers
-
-// func hasVar(r *http.Request, k string) bool {
-// 	_, found := mux.Vars(r)[k]
-// 	return found
-// }
-
-func decodeQuery(r *http.Request, i interface{}) error {
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-
-	if err := decoder.Decode(i, r.URL.Query()); err != nil {
-		return errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String())
-	}
-	return nil
-}
-
-func getRuntime(r *http.Request) *libpod.Runtime {
-	return r.Context().Value("runtime").(*libpod.Runtime)
-}
-
-// func getHeader(r *http.Request, k string) string {
-// 	return r.Header.Get(k)
-// }
-//
-// func hasHeader(r *http.Request, k string) bool {
-// 	_, found := r.Header[k]
-// 	return found
-// }
diff --git a/pkg/api/handlers/images.go b/pkg/api/handlers/images.go
deleted file mode 100644
index d4549e5b4..000000000
--- a/pkg/api/handlers/images.go
+++ /dev/null
@@ -1,187 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"strconv"
-
-	"github.com/containers/image/v5/types"
-	"github.com/containers/libpod/libpod"
-	"github.com/containers/libpod/libpod/image"
-	"github.com/containers/libpod/pkg/api/handlers/utils"
-	"github.com/gorilla/schema"
-	"github.com/pkg/errors"
-)
-
-func HistoryImage(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	name := utils.GetName(r)
-	var allHistory []HistoryResponse
-
-	newImage, 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
-
-	}
-	history, err := newImage.History(r.Context())
-	if err != nil {
-		utils.InternalServerError(w, err)
-		return
-	}
-	for _, h := range history {
-		l := HistoryResponse{
-			ID:        h.ID,
-			Created:   h.Created.UnixNano(),
-			CreatedBy: h.CreatedBy,
-			Tags:      h.Tags,
-			Size:      h.Size,
-			Comment:   h.Comment,
-		}
-		allHistory = append(allHistory, l)
-	}
-	utils.WriteResponse(w, http.StatusOK, allHistory)
-}
-
-func TagImage(w http.ResponseWriter, r *http.Request) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-
-	// /v1.xx/images/(name)/tag
-	name := utils.GetName(r)
-	newImage, err := runtime.ImageRuntime().NewFromLocal(name)
-	if err != nil {
-		utils.ImageNotFound(w, name, errors.Wrapf(err, "Failed to find image %s", name))
-		return
-	}
-	tag := "latest"
-	if len(r.Form.Get("tag")) > 0 {
-		tag = r.Form.Get("tag")
-	}
-	if len(r.Form.Get("repo")) < 1 {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.New("repo parameter is required to tag an image"))
-		return
-	}
-	repo := r.Form.Get("repo")
-	tagName := fmt.Sprintf("%s:%s", repo, tag)
-	if err := newImage.TagImage(tagName); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, err)
-		return
-	}
-	utils.WriteResponse(w, http.StatusCreated, "")
-}
-
-func RemoveImage(w http.ResponseWriter, r *http.Request) {
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-
-	query := struct {
-		noPrune bool
-	}{
-		// This is where you can override the golang default value for one of fields
-	}
-
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return
-	}
-	if _, found := r.URL.Query()["noprune"]; found {
-		if query.noPrune {
-			utils.UnSupportedParameter("noprune")
-		}
-	}
-	name := utils.GetName(r)
-	newImage, err := runtime.ImageRuntime().NewFromLocal(name)
-	if err != nil {
-		utils.ImageNotFound(w, name, errors.Wrapf(err, "Failed to find image %s", name))
-		return
-	}
-
-	force := false
-	if len(r.Form.Get("force")) > 0 {
-		force, err = strconv.ParseBool(r.Form.Get("force"))
-		if err != nil {
-			utils.Error(w, "Something went wrong.", http.StatusBadRequest, err)
-			return
-		}
-	}
-	_, err = runtime.RemoveImage(r.Context(), newImage, force)
-	if err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, err)
-		return
-	}
-	// TODO
-	// This will need to be fixed for proper response, like Deleted: and Untagged:
-	m := make(map[string]string)
-	m["Deleted"] = newImage.ID()
-	foo := []map[string]string{}
-	foo = append(foo, m)
-	utils.WriteResponse(w, http.StatusOK, foo)
-
-}
-func GetImage(r *http.Request, name string) (*image.Image, error) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	return runtime.ImageRuntime().NewFromLocal(name)
-}
-
-func SaveFromBody(f *os.File, r *http.Request) error { // nolint
-	if _, err := io.Copy(f, r.Body); err != nil {
-		return err
-	}
-	return f.Close()
-}
-
-func SearchImages(w http.ResponseWriter, r *http.Request) {
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	query := struct {
-		Term    string              `json:"term"`
-		Limit   int                 `json:"limit"`
-		Filters map[string][]string `json:"filters"`
-	}{
-		// This is where you can override the golang default value for one of fields
-	}
-
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return
-	}
-
-	filter := image.SearchFilter{}
-	if len(query.Filters) > 0 {
-		if len(query.Filters["stars"]) > 0 {
-			stars, err := strconv.Atoi(query.Filters["stars"][0])
-			if err != nil {
-				utils.InternalServerError(w, err)
-				return
-			}
-			filter.Stars = stars
-		}
-		if len(query.Filters["is-official"]) > 0 {
-			isOfficial, err := strconv.ParseBool(query.Filters["is-official"][0])
-			if err != nil {
-				utils.InternalServerError(w, err)
-				return
-			}
-			filter.IsOfficial = types.NewOptionalBool(isOfficial)
-		}
-		if len(query.Filters["is-automated"]) > 0 {
-			isAutomated, err := strconv.ParseBool(query.Filters["is-automated"][0])
-			if err != nil {
-				utils.InternalServerError(w, err)
-				return
-			}
-			filter.IsAutomated = types.NewOptionalBool(isAutomated)
-		}
-	}
-	options := image.SearchOptions{
-		Filter: filter,
-		Limit:  query.Limit,
-	}
-	results, err := image.SearchImages(query.Term, options)
-	if err != nil {
-		utils.BadRequest(w, "term", query.Term, err)
-		return
-	}
-	utils.WriteResponse(w, http.StatusOK, results)
-}
diff --git a/pkg/api/handlers/libpod/containers.go b/pkg/api/handlers/libpod/containers.go
index d8dd0d69b..8020c391d 100644
--- a/pkg/api/handlers/libpod/containers.go
+++ b/pkg/api/handlers/libpod/containers.go
@@ -10,17 +10,12 @@ import (
 	"github.com/containers/libpod/cmd/podman/shared"
 	"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/gorilla/schema"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-func StopContainer(w http.ResponseWriter, r *http.Request) {
-	handlers.StopContainer(w, r)
-}
-
 func ContainerExists(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	name := utils.GetName(r)
@@ -32,22 +27,6 @@ func ContainerExists(w http.ResponseWriter, r *http.Request) {
 	utils.WriteResponse(w, http.StatusNoContent, "")
 }
 
-func RemoveContainer(w http.ResponseWriter, r *http.Request) {
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	query := struct {
-		Force bool `schema:"force"`
-		Vols  bool `schema:"v"`
-	}{
-		// 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
-	}
-	utils.RemoveContainer(w, r, query.Force, query.Vols)
-}
 func ListContainers(w http.ResponseWriter, r *http.Request) {
 	var (
 		filterFuncs []libpod.ContainerFilter
@@ -165,16 +144,6 @@ func GetContainer(w http.ResponseWriter, r *http.Request) {
 	utils.WriteResponse(w, http.StatusOK, data)
 }
 
-func KillContainer(w http.ResponseWriter, r *http.Request) {
-	// /{version}/containers/(name)/kill
-	_, err := utils.KillContainer(w, r)
-	if err != nil {
-		return
-	}
-	// Success
-	utils.WriteResponse(w, http.StatusNoContent, "")
-}
-
 func WaitContainer(w http.ResponseWriter, r *http.Request) {
 	exitCode, err := utils.WaitContainer(w, r)
 	if err != nil {
diff --git a/pkg/api/handlers/libpod/images.go b/pkg/api/handlers/libpod/images.go
index 71603e6cc..cfd3b993e 100644
--- a/pkg/api/handlers/libpod/images.go
+++ b/pkg/api/handlers/libpod/images.go
@@ -79,7 +79,7 @@ func ImageTree(w http.ResponseWriter, r *http.Request) {
 
 func GetImage(w http.ResponseWriter, r *http.Request) {
 	name := utils.GetName(r)
-	newImage, err := handlers.GetImage(r, name)
+	newImage, err := utils.GetImage(r, name)
 	if err != nil {
 		utils.Error(w, "Something went wrong.", http.StatusNotFound, errors.Wrapf(err, "Failed to find image %s", name))
 		return
diff --git a/pkg/api/handlers/utils/containers.go b/pkg/api/handlers/utils/containers.go
index 07efef0f5..d5a79bdc8 100644
--- a/pkg/api/handlers/utils/containers.go
+++ b/pkg/api/handlers/utils/containers.go
@@ -2,9 +2,7 @@ package utils
 
 import (
 	"context"
-	"fmt"
 	"net/http"
-	"syscall"
 	"time"
 
 	"github.com/containers/libpod/cmd/podman/shared"
@@ -23,60 +21,6 @@ type ContainerCreateResponse struct {
 	Warnings []string `json:"Warnings"`
 }
 
-func KillContainer(w http.ResponseWriter, r *http.Request) (*libpod.Container, error) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	query := struct {
-		Signal syscall.Signal `schema:"signal"`
-	}{
-		Signal: syscall.SIGKILL,
-	}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "Failed to parse parameters for %s", r.URL.String()))
-		return nil, err
-	}
-	name := GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		ContainerNotFound(w, name, err)
-		return nil, err
-	}
-
-	state, err := con.State()
-	if err != nil {
-		InternalServerError(w, err)
-		return con, err
-	}
-
-	// If the Container is stopped already, send a 409
-	if state == define.ContainerStateStopped || state == define.ContainerStateExited {
-		Error(w, fmt.Sprintf("Container %s is not running", name), http.StatusConflict, errors.New(fmt.Sprintf("Cannot kill Container %s, it is not running", name)))
-		return con, err
-	}
-
-	err = con.Kill(uint(query.Signal))
-	if err != nil {
-		Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "unable to kill Container %s", name))
-	}
-	return con, err
-}
-
-func RemoveContainer(w http.ResponseWriter, r *http.Request, force, vols bool) {
-	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	name := GetName(r)
-	con, err := runtime.LookupContainer(name)
-	if err != nil {
-		ContainerNotFound(w, name, err)
-		return
-	}
-
-	if err := runtime.RemoveContainer(r.Context(), con, force, vols); err != nil {
-		InternalServerError(w, err)
-		return
-	}
-	WriteResponse(w, http.StatusNoContent, "")
-}
-
 func WaitContainer(w http.ResponseWriter, r *http.Request) (int32, error) {
 	var (
 		err      error
diff --git a/pkg/api/handlers/utils/images.go b/pkg/api/handlers/utils/images.go
index a97fd5c07..696d5f745 100644
--- a/pkg/api/handlers/utils/images.go
+++ b/pkg/api/handlers/utils/images.go
@@ -43,3 +43,8 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 	}
 
 }
+
+func GetImage(r *http.Request, name string) (*image.Image, error) {
+	runtime := r.Context().Value("runtime").(*libpod.Runtime)
+	return runtime.ImageRuntime().NewFromLocal(name)
+}
diff --git a/pkg/api/server/register_auth.go b/pkg/api/server/register_auth.go
index 7e51c2b63..33b707fa4 100644
--- a/pkg/api/server/register_auth.go
+++ b/pkg/api/server/register_auth.go
@@ -1,13 +1,13 @@
 package server
 
 import (
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerAuthHandlers(r *mux.Router) error {
-	r.Handle(VersionedPath("/auth"), s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle(VersionedPath("/auth"), s.APIHandler(compat.UnsupportedHandler))
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/auth", s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle("/auth", s.APIHandler(compat.UnsupportedHandler))
 	return nil
 }
diff --git a/pkg/api/server/register_containers.go b/pkg/api/server/register_containers.go
index a87e8eaee..2656d1d89 100644
--- a/pkg/api/server/register_containers.go
+++ b/pkg/api/server/register_containers.go
@@ -3,8 +3,7 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
-	"github.com/containers/libpod/pkg/api/handlers/generic"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/containers/libpod/pkg/api/handlers/libpod"
 	"github.com/gorilla/mux"
 )
@@ -33,9 +32,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//       $ref: "#/responses/ConflictError"
 	//     500:
 	//       $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/create"), s.APIHandler(generic.CreateContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/create"), s.APIHandler(compat.CreateContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/create", s.APIHandler(generic.CreateContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/create", s.APIHandler(compat.CreateContainer)).Methods(http.MethodPost)
 	// swagger:operation GET /containers/json compat listContainers
 	// ---
 	// tags:
@@ -85,9 +84,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/BadParamError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/json"), s.APIHandler(generic.ListContainers)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/containers/json"), s.APIHandler(compat.ListContainers)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/json", s.APIHandler(generic.ListContainers)).Methods(http.MethodGet)
+	r.HandleFunc("/containers/json", s.APIHandler(compat.ListContainers)).Methods(http.MethodGet)
 	// swagger:operation POST  /containers/prune compat pruneContainers
 	// ---
 	// tags:
@@ -109,9 +108,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/DocsContainerPruneReport"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/prune"), s.APIHandler(handlers.PruneContainers)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/prune"), s.APIHandler(compat.PruneContainers)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/prune", s.APIHandler(handlers.PruneContainers)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/prune", s.APIHandler(compat.PruneContainers)).Methods(http.MethodPost)
 	// swagger:operation DELETE /containers/{name} compat removeContainer
 	// ---
 	// tags:
@@ -150,9 +149,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/ConflictError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}"), s.APIHandler(generic.RemoveContainer)).Methods(http.MethodDelete)
+	r.HandleFunc(VersionedPath("/containers/{name}"), s.APIHandler(compat.RemoveContainer)).Methods(http.MethodDelete)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}", s.APIHandler(generic.RemoveContainer)).Methods(http.MethodDelete)
+	r.HandleFunc("/containers/{name}", s.APIHandler(compat.RemoveContainer)).Methods(http.MethodDelete)
 	// swagger:operation GET /containers/{name}/json compat getContainer
 	// ---
 	// tags:
@@ -179,9 +178,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/json"), s.APIHandler(generic.GetContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/containers/{name}/json"), s.APIHandler(compat.GetContainer)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/json", s.APIHandler(generic.GetContainer)).Methods(http.MethodGet)
+	r.HandleFunc("/containers/{name}/json", s.APIHandler(compat.GetContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /containers/{name}/kill compat killContainer
 	// ---
 	// tags:
@@ -211,9 +210,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/ConflictError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/kill"), s.APIHandler(generic.KillContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/kill"), s.APIHandler(compat.KillContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/kill", s.APIHandler(generic.KillContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/kill", s.APIHandler(compat.KillContainer)).Methods(http.MethodPost)
 	// swagger:operation GET /containers/{name}/logs compat logsFromContainer
 	// ---
 	// tags:
@@ -265,9 +264,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//      $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//      $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/logs"), s.APIHandler(generic.LogsFromContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/containers/{name}/logs"), s.APIHandler(compat.LogsFromContainer)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/logs", s.APIHandler(generic.LogsFromContainer)).Methods(http.MethodGet)
+	r.HandleFunc("/containers/{name}/logs", s.APIHandler(compat.LogsFromContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /containers/{name}/pause compat pauseContainer
 	// ---
 	// tags:
@@ -289,12 +288,12 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/pause"), s.APIHandler(handlers.PauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/pause"), s.APIHandler(compat.PauseContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/pause", s.APIHandler(handlers.PauseContainer)).Methods(http.MethodPost)
-	r.HandleFunc(VersionedPath("/containers/{name}/rename"), s.APIHandler(handlers.UnsupportedHandler)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/pause", s.APIHandler(compat.PauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/rename"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/rename", s.APIHandler(handlers.UnsupportedHandler)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/rename", s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation POST /containers/{name}/restart compat restartContainer
 	// ---
 	// tags:
@@ -319,9 +318,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/restart"), s.APIHandler(handlers.RestartContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/restart"), s.APIHandler(compat.RestartContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/restart", s.APIHandler(handlers.RestartContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/restart", s.APIHandler(compat.RestartContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /containers/{name}/start compat startContainer
 	// ---
 	// tags:
@@ -349,9 +348,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/start"), s.APIHandler(handlers.StartContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/start"), s.APIHandler(compat.StartContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/start", s.APIHandler(handlers.StartContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/start", s.APIHandler(compat.StartContainer)).Methods(http.MethodPost)
 	// swagger:operation GET /containers/{name}/stats compat statsContainer
 	// ---
 	// tags:
@@ -378,9 +377,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/stats"), s.APIHandler(generic.StatsContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/containers/{name}/stats"), s.APIHandler(compat.StatsContainer)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/stats", s.APIHandler(generic.StatsContainer)).Methods(http.MethodGet)
+	r.HandleFunc("/containers/{name}/stats", s.APIHandler(compat.StatsContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /containers/{name}/stop compat stopContainer
 	// ---
 	// tags:
@@ -408,9 +407,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/stop"), s.APIHandler(handlers.StopContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/stop"), s.APIHandler(compat.StopContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/stop", s.APIHandler(handlers.StopContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/stop", s.APIHandler(compat.StopContainer)).Methods(http.MethodPost)
 	// swagger:operation GET /containers/{name}/top compat topContainer
 	// ---
 	// tags:
@@ -435,9 +434,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/top"), s.APIHandler(handlers.TopContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/containers/{name}/top"), s.APIHandler(compat.TopContainer)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/top", s.APIHandler(handlers.TopContainer)).Methods(http.MethodGet)
+	r.HandleFunc("/containers/{name}/top", s.APIHandler(compat.TopContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /containers/{name}/unpause compat unpauseContainer
 	// ---
 	// tags:
@@ -459,9 +458,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/unpause"), s.APIHandler(handlers.UnpauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/unpause"), s.APIHandler(compat.UnpauseContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/unpause", s.APIHandler(handlers.UnpauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/unpause", s.APIHandler(compat.UnpauseContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /containers/{name}/wait compat waitContainer
 	// ---
 	// tags:
@@ -494,9 +493,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/wait"), s.APIHandler(generic.WaitContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/wait"), s.APIHandler(compat.WaitContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/wait", s.APIHandler(generic.WaitContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/wait", s.APIHandler(compat.WaitContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /containers/{name}/attach compat attachContainer
 	// ---
 	// tags:
@@ -551,9 +550,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/attach"), s.APIHandler(handlers.AttachContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/attach"), s.APIHandler(compat.AttachContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/attach", s.APIHandler(handlers.AttachContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/attach", s.APIHandler(compat.AttachContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /containers/{name}/resize compat resizeContainer
 	// ---
 	// tags:
@@ -585,9 +584,9 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/containers/{name}/resize"), s.APIHandler(handlers.ResizeContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/containers/{name}/resize"), s.APIHandler(compat.ResizeContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/containers/{name}/resize", s.APIHandler(handlers.ResizeContainer)).Methods(http.MethodPost)
+	r.HandleFunc("/containers/{name}/resize", s.APIHandler(compat.ResizeContainer)).Methods(http.MethodPost)
 
 	/*
 		libpod endpoints
@@ -704,7 +703,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/DocsLibpodPruneResponse"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/prune"), s.APIHandler(handlers.PruneContainers)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/prune"), s.APIHandler(compat.PruneContainers)).Methods(http.MethodPost)
 	// swagger:operation GET /libpod/containers/showmounted libpod libpodShowMountedContainers
 	// ---
 	// tags:
@@ -756,7 +755,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/ConflictError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}"), s.APIHandler(libpod.RemoveContainer)).Methods(http.MethodDelete)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}"), s.APIHandler(compat.RemoveContainer)).Methods(http.MethodDelete)
 	// swagger:operation GET /libpod/containers/{name}/json libpod libpodGetContainer
 	// ---
 	// tags:
@@ -811,7 +810,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/ConflictError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/kill"), s.APIHandler(libpod.KillContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/kill"), s.APIHandler(compat.KillContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/mount libpod libpodMountContainer
 	// ---
 	// tags:
@@ -911,7 +910,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//      $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//      $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/logs"), s.APIHandler(generic.LogsFromContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/logs"), s.APIHandler(compat.LogsFromContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /libpod/containers/{name}/pause libpod libpodPauseContainer
 	// ---
 	// tags:
@@ -933,7 +932,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     "$ref": "#/responses/NoSuchContainer"
 	//   500:
 	//     "$ref": "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name:..*}/pause"), s.APIHandler(handlers.PauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name:..*}/pause"), s.APIHandler(compat.PauseContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/restart libpod libpodRestartContainer
 	// ---
 	// tags:
@@ -958,7 +957,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/restart"), s.APIHandler(handlers.RestartContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/restart"), s.APIHandler(compat.RestartContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/start libpod libpodStartContainer
 	// ---
 	// tags:
@@ -986,7 +985,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/start"), s.APIHandler(handlers.StartContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/start"), s.APIHandler(compat.StartContainer)).Methods(http.MethodPost)
 	// swagger:operation GET /libpod/containers/{name}/stats libpod libpodStatsContainer
 	// ---
 	// tags:
@@ -1013,7 +1012,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/stats"), s.APIHandler(generic.StatsContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/stats"), s.APIHandler(compat.StatsContainer)).Methods(http.MethodGet)
 	// swagger:operation GET /libpod/containers/{name}/top libpod libpodTopContainer
 	// ---
 	// tags:
@@ -1047,7 +1046,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/top"), s.APIHandler(handlers.TopContainer)).Methods(http.MethodGet)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/top"), s.APIHandler(compat.TopContainer)).Methods(http.MethodGet)
 	// swagger:operation POST /libpod/containers/{name}/unpause libpod libpodUnpauseContainer
 	// ---
 	// tags:
@@ -1068,7 +1067,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/unpause"), s.APIHandler(handlers.UnpauseContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/unpause"), s.APIHandler(compat.UnpauseContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/wait libpod libpodWaitContainer
 	// ---
 	// tags:
@@ -1150,7 +1149,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/stop"), s.APIHandler(handlers.StopContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/stop"), s.APIHandler(compat.StopContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/attach libpod libpodAttachContainer
 	// ---
 	// tags:
@@ -1205,7 +1204,7 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/attach"), s.APIHandler(handlers.AttachContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/attach"), s.APIHandler(compat.AttachContainer)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/containers/{name}/resize libpod libpodResizeContainer
 	// ---
 	// tags:
@@ -1237,6 +1236,6 @@ func (s *APIServer) registerContainersHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchContainer"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.HandleFunc(VersionedPath("/libpod/containers/{name}/resize"), s.APIHandler(handlers.ResizeContainer)).Methods(http.MethodPost)
+	r.HandleFunc(VersionedPath("/libpod/containers/{name}/resize"), s.APIHandler(compat.ResizeContainer)).Methods(http.MethodPost)
 	return nil
 }
diff --git a/pkg/api/server/register_distribution.go b/pkg/api/server/register_distribution.go
index 730129d5d..89f69ea67 100644
--- a/pkg/api/server/register_distribution.go
+++ b/pkg/api/server/register_distribution.go
@@ -1,13 +1,13 @@
 package server
 
 import (
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerDistributionHandlers(r *mux.Router) error {
-	r.HandleFunc(VersionedPath("/distribution/{name}/json"), handlers.UnsupportedHandler)
+	r.HandleFunc(VersionedPath("/distribution/{name}/json"), compat.UnsupportedHandler)
 	// Added non version path to URI to support docker non versioned paths
-	r.HandleFunc("/distribution/{name}/json", handlers.UnsupportedHandler)
+	r.HandleFunc("/distribution/{name}/json", compat.UnsupportedHandler)
 	return nil
 }
diff --git a/pkg/api/server/register_events.go b/pkg/api/server/register_events.go
index ea5d21882..96ba4596e 100644
--- a/pkg/api/server/register_events.go
+++ b/pkg/api/server/register_events.go
@@ -3,7 +3,7 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
@@ -34,8 +34,8 @@ func (s *APIServer) registerEventsHandlers(r *mux.Router) error {
 	//     description: returns a string of json data describing an event
 	//   500:
 	//     "$ref": "#/responses/InternalError"
-	r.Handle(VersionedPath("/events"), s.APIHandler(handlers.GetEvents)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/events"), s.APIHandler(compat.GetEvents)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/events", s.APIHandler(handlers.GetEvents)).Methods(http.MethodGet)
+	r.Handle("/events", s.APIHandler(compat.GetEvents)).Methods(http.MethodGet)
 	return nil
 }
diff --git a/pkg/api/server/register_exec.go b/pkg/api/server/register_exec.go
index 76033a9ca..d27d21a04 100644
--- a/pkg/api/server/register_exec.go
+++ b/pkg/api/server/register_exec.go
@@ -3,7 +3,7 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
@@ -74,9 +74,9 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//	   description: container is paused
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/containers/{name}/create"), s.APIHandler(handlers.CreateExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/containers/{name}/create"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/containers/{name}/create", s.APIHandler(handlers.CreateExec)).Methods(http.MethodPost)
+	r.Handle("/containers/{name}/create", s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation POST /exec/{id}/start compat startExec
 	// ---
 	// tags:
@@ -112,9 +112,9 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//	   description: container is stopped or paused
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/exec/{id}/start"), s.APIHandler(handlers.StartExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/exec/{id}/start"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/exec/{id}/start", s.APIHandler(handlers.StartExec)).Methods(http.MethodPost)
+	r.Handle("/exec/{id}/start", s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation POST /exec/{id}/resize compat resizeExec
 	// ---
 	// tags:
@@ -145,9 +145,9 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchExecInstance"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/exec/{id}/resize"), s.APIHandler(handlers.ResizeExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/exec/{id}/resize"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/exec/{id}/resize", s.APIHandler(handlers.ResizeExec)).Methods(http.MethodPost)
+	r.Handle("/exec/{id}/resize", s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation GET /exec/{id}/json compat inspectExec
 	// ---
 	// tags:
@@ -169,9 +169,9 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchExecInstance"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/exec/{id}/json"), s.APIHandler(handlers.InspectExec)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/exec/{id}/json"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/exec/{id}/json", s.APIHandler(handlers.InspectExec)).Methods(http.MethodGet)
+	r.Handle("/exec/{id}/json", s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodGet)
 
 	/*
 		libpod api follows
@@ -243,7 +243,7 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//	   description: container is paused
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/libpod/containers/{name}/create"), s.APIHandler(handlers.CreateExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/libpod/containers/{name}/create"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/exec/{id}/start libpod libpodStartExec
 	// ---
 	// tags:
@@ -279,7 +279,7 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//	   description: container is stopped or paused
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/libpod/exec/{id}/start"), s.APIHandler(handlers.StartExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/libpod/exec/{id}/start"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation POST /libpod/exec/{id}/resize libpod libpodResizeExec
 	// ---
 	// tags:
@@ -310,7 +310,7 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchExecInstance"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/libpod/exec/{id}/resize"), s.APIHandler(handlers.ResizeExec)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/libpod/exec/{id}/resize"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodPost)
 	// swagger:operation GET /libpod/exec/{id}/json libpod libpodInspectExec
 	// ---
 	// tags:
@@ -332,6 +332,6 @@ func (s *APIServer) registerExecHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchExecInstance"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/libpod/exec/{id}/json"), s.APIHandler(handlers.InspectExec)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/libpod/exec/{id}/json"), s.APIHandler(compat.UnsupportedHandler)).Methods(http.MethodGet)
 	return nil
 }
diff --git a/pkg/api/server/register_images.go b/pkg/api/server/register_images.go
index 8c75c4d04..e6ad045a2 100644
--- a/pkg/api/server/register_images.go
+++ b/pkg/api/server/register_images.go
@@ -3,8 +3,7 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
-	"github.com/containers/libpod/pkg/api/handlers/generic"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/containers/libpod/pkg/api/handlers/libpod"
 	"github.com/gorilla/mux"
 )
@@ -47,12 +46,12 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchImage"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/images/create"), s.APIHandler(generic.CreateImageFromImage)).Methods(http.MethodPost).Queries("fromImage", "{fromImage}")
+	r.Handle(VersionedPath("/images/create"), s.APIHandler(compat.CreateImageFromImage)).Methods(http.MethodPost).Queries("fromImage", "{fromImage}")
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/create", s.APIHandler(generic.CreateImageFromImage)).Methods(http.MethodPost).Queries("fromImage", "{fromImage}")
-	r.Handle(VersionedPath("/images/create"), s.APIHandler(generic.CreateImageFromSrc)).Methods(http.MethodPost).Queries("fromSrc", "{fromSrc}")
+	r.Handle("/images/create", s.APIHandler(compat.CreateImageFromImage)).Methods(http.MethodPost).Queries("fromImage", "{fromImage}")
+	r.Handle(VersionedPath("/images/create"), s.APIHandler(compat.CreateImageFromSrc)).Methods(http.MethodPost).Queries("fromSrc", "{fromSrc}")
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/create", s.APIHandler(generic.CreateImageFromSrc)).Methods(http.MethodPost).Queries("fromSrc", "{fromSrc}")
+	r.Handle("/images/create", s.APIHandler(compat.CreateImageFromSrc)).Methods(http.MethodPost).Queries("fromSrc", "{fromSrc}")
 	// swagger:operation GET /images/json compat listImages
 	// ---
 	// tags:
@@ -87,9 +86,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/DockerImageSummary"
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/json"), s.APIHandler(generic.GetImages)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/images/json"), s.APIHandler(compat.GetImages)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/json", s.APIHandler(generic.GetImages)).Methods(http.MethodGet)
+	r.Handle("/images/json", s.APIHandler(compat.GetImages)).Methods(http.MethodGet)
 	// swagger:operation POST /images/load compat importImage
 	// ---
 	// tags:
@@ -113,9 +112,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     description: no error
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/load"), s.APIHandler(generic.LoadImages)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/images/load"), s.APIHandler(compat.LoadImages)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/load", s.APIHandler(generic.LoadImages)).Methods(http.MethodPost)
+	r.Handle("/images/load", s.APIHandler(compat.LoadImages)).Methods(http.MethodPost)
 	// swagger:operation POST /images/prune compat pruneImages
 	// ---
 	// tags:
@@ -140,9 +139,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/DocsImageDeleteResponse"
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/prune"), s.APIHandler(generic.PruneImages)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/images/prune"), s.APIHandler(compat.PruneImages)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/prune", s.APIHandler(generic.PruneImages)).Methods(http.MethodPost)
+	r.Handle("/images/prune", s.APIHandler(compat.PruneImages)).Methods(http.MethodPost)
 	// swagger:operation GET /images/search compat searchImages
 	// ---
 	// tags:
@@ -175,9 +174,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/BadParamError"
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/search"), s.APIHandler(handlers.SearchImages)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/images/search"), s.APIHandler(compat.SearchImages)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/search", s.APIHandler(handlers.SearchImages)).Methods(http.MethodGet)
+	r.Handle("/images/search", s.APIHandler(compat.SearchImages)).Methods(http.MethodGet)
 	// swagger:operation DELETE /images/{name:.*} compat removeImage
 	// ---
 	// tags:
@@ -209,9 +208,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/ConflictError'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/{name:.*}"), s.APIHandler(handlers.RemoveImage)).Methods(http.MethodDelete)
+	r.Handle(VersionedPath("/images/{name:.*}"), s.APIHandler(compat.RemoveImage)).Methods(http.MethodDelete)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/{name:.*}", s.APIHandler(handlers.RemoveImage)).Methods(http.MethodDelete)
+	r.Handle("/images/{name:.*}", s.APIHandler(compat.RemoveImage)).Methods(http.MethodDelete)
 	// swagger:operation GET /images/{name:.*}/get compat exportImage
 	// ---
 	// tags:
@@ -234,9 +233,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//      format: binary
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/{name:.*}/get"), s.APIHandler(generic.ExportImage)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/images/{name:.*}/get"), s.APIHandler(compat.ExportImage)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/{name:.*}/get", s.APIHandler(generic.ExportImage)).Methods(http.MethodGet)
+	r.Handle("/images/{name:.*}/get", s.APIHandler(compat.ExportImage)).Methods(http.MethodGet)
 	// swagger:operation GET /images/{name:.*}/history compat imageHistory
 	// ---
 	// tags:
@@ -258,9 +257,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchImage"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/images/{name:.*}/history"), s.APIHandler(handlers.HistoryImage)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/images/{name:.*}/history"), s.APIHandler(compat.HistoryImage)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/{name:.*}/history", s.APIHandler(handlers.HistoryImage)).Methods(http.MethodGet)
+	r.Handle("/images/{name:.*}/history", s.APIHandler(compat.HistoryImage)).Methods(http.MethodGet)
 	// swagger:operation GET /images/{name:.*}/json compat inspectImage
 	// ---
 	// tags:
@@ -282,9 +281,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/NoSuchImage"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/images/{name:.*}/json"), s.APIHandler(generic.GetImage)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/images/{name:.*}/json"), s.APIHandler(compat.GetImage)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/{name:.*}/json", s.APIHandler(generic.GetImage)).Methods(http.MethodGet)
+	r.Handle("/images/{name:.*}/json", s.APIHandler(compat.GetImage)).Methods(http.MethodGet)
 	// swagger:operation POST /images/{name:.*}/tag compat tagImage
 	// ---
 	// tags:
@@ -318,9 +317,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/ConflictError'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/images/{name:.*}/tag"), s.APIHandler(handlers.TagImage)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/images/{name:.*}/tag"), s.APIHandler(compat.TagImage)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/images/{name:.*}/tag", s.APIHandler(handlers.TagImage)).Methods(http.MethodPost)
+	r.Handle("/images/{name:.*}/tag", s.APIHandler(compat.TagImage)).Methods(http.MethodPost)
 	// swagger:operation POST /commit compat commitContainer
 	// ---
 	// tags:
@@ -365,9 +364,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/NoSuchImage'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/commit"), s.APIHandler(generic.CommitContainer)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/commit"), s.APIHandler(compat.CommitContainer)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/commit", s.APIHandler(generic.CommitContainer)).Methods(http.MethodPost)
+	r.Handle("/commit", s.APIHandler(compat.CommitContainer)).Methods(http.MethodPost)
 
 	// swagger:operation POST /build compat buildImage
 	// ---
@@ -577,9 +576,9 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: "#/responses/BadParamError"
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/build"), s.APIHandler(handlers.BuildImage)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/build"), s.APIHandler(compat.BuildImage)).Methods(http.MethodPost)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/build", s.APIHandler(handlers.BuildImage)).Methods(http.MethodPost)
+	r.Handle("/build", s.APIHandler(compat.BuildImage)).Methods(http.MethodPost)
 	/*
 		libpod endpoints
 	*/
@@ -653,7 +652,7 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/NoSuchImage'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/libpod/images/{name:.*}/history"), s.APIHandler(handlers.HistoryImage)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/libpod/images/{name:.*}/history"), s.APIHandler(compat.HistoryImage)).Methods(http.MethodGet)
 	// swagger:operation GET /libpod/images/json libpod libpodListImages
 	// ---
 	// tags:
@@ -848,7 +847,7 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//      $ref: "#/responses/DocsSearchResponse"
 	//   500:
 	//      $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/libpod/images/search"), s.APIHandler(handlers.SearchImages)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/libpod/images/search"), s.APIHandler(compat.SearchImages)).Methods(http.MethodGet)
 	// swagger:operation DELETE /libpod/images/{name:.*} libpod libpodRemoveImage
 	// ---
 	// tags:
@@ -878,7 +877,7 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/ConflictError'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/libpod/images/{name:.*}"), s.APIHandler(handlers.RemoveImage)).Methods(http.MethodDelete)
+	r.Handle(VersionedPath("/libpod/images/{name:.*}"), s.APIHandler(compat.RemoveImage)).Methods(http.MethodDelete)
 	// swagger:operation GET /libpod/images/{name:.*}/get libpod libpodExportImage
 	// ---
 	// tags:
@@ -967,7 +966,7 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/ConflictError'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/libpod/images/{name:.*}/tag"), s.APIHandler(handlers.TagImage)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/libpod/images/{name:.*}/tag"), s.APIHandler(compat.TagImage)).Methods(http.MethodPost)
 	// swagger:operation POST /commit libpod libpodCommitContainer
 	// ---
 	// tags:
@@ -1012,6 +1011,6 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
 	//     $ref: '#/responses/NoSuchImage'
 	//   500:
 	//     $ref: '#/responses/InternalError'
-	r.Handle(VersionedPath("/commit"), s.APIHandler(generic.CommitContainer)).Methods(http.MethodPost)
+	r.Handle(VersionedPath("/commit"), s.APIHandler(compat.CommitContainer)).Methods(http.MethodPost)
 	return nil
 }
diff --git a/pkg/api/server/register_info.go b/pkg/api/server/register_info.go
index 975a19fef..b4ab8871c 100644
--- a/pkg/api/server/register_info.go
+++ b/pkg/api/server/register_info.go
@@ -3,7 +3,7 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers/generic"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
@@ -21,8 +21,8 @@ func (s *APIServer) registerInfoHandlers(r *mux.Router) error {
 	//     description: to be determined
 	//   500:
 	//     $ref: "#/responses/InternalError"
-	r.Handle(VersionedPath("/info"), s.APIHandler(generic.GetInfo)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/info"), s.APIHandler(compat.GetInfo)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/info", s.APIHandler(generic.GetInfo)).Methods(http.MethodGet)
+	r.Handle("/info", s.APIHandler(compat.GetInfo)).Methods(http.MethodGet)
 	return nil
 }
diff --git a/pkg/api/server/register_monitor.go b/pkg/api/server/register_monitor.go
index b821efbaa..b7a7c3792 100644
--- a/pkg/api/server/register_monitor.go
+++ b/pkg/api/server/register_monitor.go
@@ -1,13 +1,13 @@
 package server
 
 import (
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerMonitorHandlers(r *mux.Router) error {
-	r.Handle(VersionedPath("/monitor"), s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle(VersionedPath("/monitor"), s.APIHandler(compat.UnsupportedHandler))
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/monitor", s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle("/monitor", s.APIHandler(compat.UnsupportedHandler))
 	return nil
 }
diff --git a/pkg/api/server/register_ping.go b/pkg/api/server/register_ping.go
index 349a8a71a..8a1cda3d4 100644
--- a/pkg/api/server/register_ping.go
+++ b/pkg/api/server/register_ping.go
@@ -3,14 +3,14 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerPingHandlers(r *mux.Router) error {
 
-	r.Handle("/_ping", s.APIHandler(handlers.Ping)).Methods(http.MethodGet)
-	r.Handle("/_ping", s.APIHandler(handlers.Ping)).Methods(http.MethodHead)
+	r.Handle("/_ping", s.APIHandler(compat.Ping)).Methods(http.MethodGet)
+	r.Handle("/_ping", s.APIHandler(compat.Ping)).Methods(http.MethodHead)
 
 	// swagger:operation GET /libpod/_ping libpod libpodPingGet
 	// ---
@@ -61,7 +61,7 @@ func (s *APIServer) registerPingHandlers(r *mux.Router) error {
 	//               determine if talking to Podman engine or another engine
 	//     500:
 	//       $ref: "#/responses/InternalError"
-	r.Handle("/libpod/_ping", s.APIHandler(handlers.Ping)).Methods(http.MethodGet)
-	r.Handle("/libpod/_ping", s.APIHandler(handlers.Ping)).Methods(http.MethodHead)
+	r.Handle("/libpod/_ping", s.APIHandler(compat.Ping)).Methods(http.MethodGet)
+	r.Handle("/libpod/_ping", s.APIHandler(compat.Ping)).Methods(http.MethodHead)
 	return nil
 }
diff --git a/pkg/api/server/register_plugins.go b/pkg/api/server/register_plugins.go
index 50026f6ad..5f6473fe8 100644
--- a/pkg/api/server/register_plugins.go
+++ b/pkg/api/server/register_plugins.go
@@ -1,13 +1,13 @@
 package server
 
 import (
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerPluginsHandlers(r *mux.Router) error {
-	r.Handle(VersionedPath("/plugins"), s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle(VersionedPath("/plugins"), s.APIHandler(compat.UnsupportedHandler))
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/plugins", s.APIHandler(handlers.UnsupportedHandler))
+	r.Handle("/plugins", s.APIHandler(compat.UnsupportedHandler))
 	return nil
 }
diff --git a/pkg/api/server/register_system.go b/pkg/api/server/register_system.go
index 4776692f5..708ccd39b 100644
--- a/pkg/api/server/register_system.go
+++ b/pkg/api/server/register_system.go
@@ -3,13 +3,13 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers/generic"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerSystemHandlers(r *mux.Router) error {
-	r.Handle(VersionedPath("/system/df"), s.APIHandler(generic.GetDiskUsage)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/system/df"), s.APIHandler(compat.GetDiskUsage)).Methods(http.MethodGet)
 	// Added non version path to URI to support docker non versioned paths
-	r.Handle("/system/df", s.APIHandler(generic.GetDiskUsage)).Methods(http.MethodGet)
+	r.Handle("/system/df", s.APIHandler(compat.GetDiskUsage)).Methods(http.MethodGet)
 	return nil
 }
diff --git a/pkg/api/server/register_version.go b/pkg/api/server/register_version.go
index ee01ad4b3..25cacbc61 100644
--- a/pkg/api/server/register_version.go
+++ b/pkg/api/server/register_version.go
@@ -3,12 +3,12 @@ package server
 import (
 	"net/http"
 
-	"github.com/containers/libpod/pkg/api/handlers"
+	"github.com/containers/libpod/pkg/api/handlers/compat"
 	"github.com/gorilla/mux"
 )
 
 func (s *APIServer) registerVersionHandlers(r *mux.Router) error {
-	r.Handle("/version", s.APIHandler(handlers.VersionHandler)).Methods(http.MethodGet)
-	r.Handle(VersionedPath("/version"), s.APIHandler(handlers.VersionHandler)).Methods(http.MethodGet)
+	r.Handle("/version", s.APIHandler(compat.VersionHandler)).Methods(http.MethodGet)
+	r.Handle(VersionedPath("/version"), s.APIHandler(compat.VersionHandler)).Methods(http.MethodGet)
 	return nil
 }