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>

34 files changed, 616 insertions, 626 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)
+}