@@ -1,9 +1,6 @@

 package build

-import (

-	"github.com/docker/docker/api/server/router"

-	"github.com/docker/docker/api/server/router/local"

-)

+import "github.com/docker/docker/api/server/router"

 // buildRouter is a router to talk with the build controller

 type buildRouter struct {

@@ -27,6 +24,6 @@ func (r *buildRouter) Routes() []router.Route {

 func (r *buildRouter) initRoutes() {

 	r.routes = []router.Route{

-		local.NewPostRoute("/build", r.postBuild),

+		router.NewPostRoute("/build", r.postBuild),

 	}

 }

@@ -4,11 +4,11 @@ import (

 	"io"

 	"time"

-	"github.com/docker/docker/daemon"

 	"github.com/docker/docker/daemon/exec"

 	"github.com/docker/docker/pkg/archive"

 	"github.com/docker/docker/pkg/version"

 	"github.com/docker/engine-api/types"

+	"github.com/docker/engine-api/types/backend"

 	"github.com/docker/engine-api/types/container"

 )

@@ -51,17 +51,17 @@ type stateBackend interface {

 type monitorBackend interface {

 	ContainerChanges(name string) ([]archive.Change, error)

 	ContainerInspect(name string, size bool, version version.Version) (interface{}, error)

-	ContainerLogs(name string, config *daemon.ContainerLogsConfig) error

-	ContainerStats(name string, config *daemon.ContainerStatsConfig) error

+	ContainerLogs(name string, config *backend.ContainerLogsConfig) error

+	ContainerStats(name string, config *backend.ContainerStatsConfig) error

 	ContainerTop(name string, psArgs string) (*types.ContainerProcessList, error)

-	Containers(config *daemon.ContainersConfig) ([]*types.Container, error)

+	Containers(config *backend.ContainersConfig) ([]*types.Container, error)

 }

 // attachBackend includes function to implement to provide container attaching functionality.

 type attachBackend interface {

-	ContainerAttachWithLogs(name string, c *daemon.ContainerAttachWithLogsConfig) error

-	ContainerWsAttachWithLogs(name string, c *daemon.ContainerWsAttachWithLogsConfig) error

+	ContainerAttachWithLogs(name string, c *backend.ContainerAttachWithLogsConfig) error

+	ContainerWsAttachWithLogs(name string, c *backend.ContainerWsAttachWithLogsConfig) error

 }

 // Backend is all the methods that need to be implemented to provide container specific functionality.

@@ -1,9 +1,6 @@

 package container

-import (

-	"github.com/docker/docker/api/server/router"

-	"github.com/docker/docker/api/server/router/local"

-)

+import "github.com/docker/docker/api/server/router"

 // containerRouter is a router to talk with the container controller

 type containerRouter struct {

@@ -20,7 +17,7 @@ func NewRouter(b Backend) router.Router {

 	return r

 }

-// Routes returns the available routers to the container controller

+// Routes returns the available routes to the container controller

 func (r *containerRouter) Routes() []router.Route {

 	return r.routes

 }

@@ -29,38 +26,38 @@ func (r *containerRouter) Routes() []router.Route {

 func (r *containerRouter) initRoutes() {

 	r.routes = []router.Route{

 		// HEAD

-		local.NewHeadRoute("/containers/{name:.*}/archive", r.headContainersArchive),

+		router.NewHeadRoute("/containers/{name:.*}/archive", r.headContainersArchive),

 		// GET

-		local.NewGetRoute("/containers/json", r.getContainersJSON),

-		local.NewGetRoute("/containers/{name:.*}/export", r.getContainersExport),

-		local.NewGetRoute("/containers/{name:.*}/changes", r.getContainersChanges),

-		local.NewGetRoute("/containers/{name:.*}/json", r.getContainersByName),

-		local.NewGetRoute("/containers/{name:.*}/top", r.getContainersTop),

-		local.NewGetRoute("/containers/{name:.*}/logs", r.getContainersLogs),

-		local.NewGetRoute("/containers/{name:.*}/stats", r.getContainersStats),

-		local.NewGetRoute("/containers/{name:.*}/attach/ws", r.wsContainersAttach),

-		local.NewGetRoute("/exec/{id:.*}/json", r.getExecByID),

-		local.NewGetRoute("/containers/{name:.*}/archive", r.getContainersArchive),

+		router.NewGetRoute("/containers/json", r.getContainersJSON),

+		router.NewGetRoute("/containers/{name:.*}/export", r.getContainersExport),

+		router.NewGetRoute("/containers/{name:.*}/changes", r.getContainersChanges),

+		router.NewGetRoute("/containers/{name:.*}/json", r.getContainersByName),

+		router.NewGetRoute("/containers/{name:.*}/top", r.getContainersTop),

+		router.NewGetRoute("/containers/{name:.*}/logs", r.getContainersLogs),

+		router.NewGetRoute("/containers/{name:.*}/stats", r.getContainersStats),

+		router.NewGetRoute("/containers/{name:.*}/attach/ws", r.wsContainersAttach),

+		router.NewGetRoute("/exec/{id:.*}/json", r.getExecByID),

+		router.NewGetRoute("/containers/{name:.*}/archive", r.getContainersArchive),

 		// POST

-		local.NewPostRoute("/containers/create", r.postContainersCreate),

-		local.NewPostRoute("/containers/{name:.*}/kill", r.postContainersKill),

-		local.NewPostRoute("/containers/{name:.*}/pause", r.postContainersPause),

-		local.NewPostRoute("/containers/{name:.*}/unpause", r.postContainersUnpause),

-		local.NewPostRoute("/containers/{name:.*}/restart", r.postContainersRestart),

-		local.NewPostRoute("/containers/{name:.*}/start", r.postContainersStart),

-		local.NewPostRoute("/containers/{name:.*}/stop", r.postContainersStop),

-		local.NewPostRoute("/containers/{name:.*}/wait", r.postContainersWait),

-		local.NewPostRoute("/containers/{name:.*}/resize", r.postContainersResize),

-		local.NewPostRoute("/containers/{name:.*}/attach", r.postContainersAttach),

-		local.NewPostRoute("/containers/{name:.*}/copy", r.postContainersCopy),

-		local.NewPostRoute("/containers/{name:.*}/exec", r.postContainerExecCreate),

-		local.NewPostRoute("/exec/{name:.*}/start", r.postContainerExecStart),

-		local.NewPostRoute("/exec/{name:.*}/resize", r.postContainerExecResize),

-		local.NewPostRoute("/containers/{name:.*}/rename", r.postContainerRename),

-		local.NewPostRoute("/containers/{name:.*}/update", r.postContainerUpdate),

+		router.NewPostRoute("/containers/create", r.postContainersCreate),

+		router.NewPostRoute("/containers/{name:.*}/kill", r.postContainersKill),

+		router.NewPostRoute("/containers/{name:.*}/pause", r.postContainersPause),

+		router.NewPostRoute("/containers/{name:.*}/unpause", r.postContainersUnpause),

+		router.NewPostRoute("/containers/{name:.*}/restart", r.postContainersRestart),

+		router.NewPostRoute("/containers/{name:.*}/start", r.postContainersStart),

+		router.NewPostRoute("/containers/{name:.*}/stop", r.postContainersStop),

+		router.NewPostRoute("/containers/{name:.*}/wait", r.postContainersWait),

+		router.NewPostRoute("/containers/{name:.*}/resize", r.postContainersResize),

+		router.NewPostRoute("/containers/{name:.*}/attach", r.postContainersAttach),

+		router.NewPostRoute("/containers/{name:.*}/copy", r.postContainersCopy),

+		router.NewPostRoute("/containers/{name:.*}/exec", r.postContainerExecCreate),

+		router.NewPostRoute("/exec/{name:.*}/start", r.postContainerExecStart),

+		router.NewPostRoute("/exec/{name:.*}/resize", r.postContainerExecResize),

+		router.NewPostRoute("/containers/{name:.*}/rename", r.postContainerRename),

+		router.NewPostRoute("/containers/{name:.*}/update", r.postContainerUpdate),

 		// PUT

-		local.NewPutRoute("/containers/{name:.*}/archive", r.putContainersArchive),

+		router.NewPutRoute("/containers/{name:.*}/archive", r.putContainersArchive),

 		// DELETE

-		local.NewDeleteRoute("/containers/{name:.*}", r.deleteContainers),

+		router.NewDeleteRoute("/containers/{name:.*}", r.deleteContainers),

 	}

 }

@@ -13,7 +13,6 @@ import (

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/distribution/registry/api/errcode"

 	"github.com/docker/docker/api/server/httputils"

-	"github.com/docker/docker/daemon"

 	derr "github.com/docker/docker/errors"

 	"github.com/docker/docker/pkg/ioutils"

 	"github.com/docker/docker/pkg/signal"

@@ -21,6 +20,7 @@ import (

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/utils"

 	"github.com/docker/engine-api/types"

+	"github.com/docker/engine-api/types/backend"

 	"github.com/docker/engine-api/types/container"

 	timetypes "github.com/docker/engine-api/types/time"

 	"golang.org/x/net/context"

@@ -32,7 +32,7 @@ func (s *containerRouter) getContainersJSON(ctx context.Context, w http.Response

 		return err

 	}

-	config := &daemon.ContainersConfig{

+	config := &backend.ContainersConfig{

 		All:     httputils.BoolValue(r, "all"),

 		Size:    httputils.BoolValue(r, "size"),

 		Since:   r.Form.Get("since"),

@@ -77,11 +77,11 @@ func (s *containerRouter) getContainersStats(ctx context.Context, w http.Respons

 		closeNotifier = notifier.CloseNotify()

 	}

-	config := &daemon.ContainerStatsConfig{

+	config := &backend.ContainerStatsConfig{

 		Stream:    stream,

 		OutStream: out,

 		Stop:      closeNotifier,

-		Version:   httputils.VersionFromContext(ctx),

+		Version:   string(httputils.VersionFromContext(ctx)),

 	}

 	return s.backend.ContainerStats(vars["name"], config)

@@ -133,7 +133,7 @@ func (s *containerRouter) getContainersLogs(ctx context.Context, w http.Response

 	output := ioutils.NewWriteFlusher(w)

 	defer output.Close()

-	logsConfig := &daemon.ContainerLogsConfig{

+	logsConfig := &backend.ContainerLogsConfig{

 		Follow:     httputils.BoolValue(r, "follow"),

 		Timestamps: httputils.BoolValue(r, "timestamps"),

 		Since:      since,

@@ -446,7 +446,7 @@ func (s *containerRouter) postContainersAttach(ctx context.Context, w http.Respo

 		}

 	}

-	attachWithLogsConfig := &daemon.ContainerAttachWithLogsConfig{

+	attachWithLogsConfig := &backend.ContainerAttachWithLogsConfig{

 		Hijacker:   w.(http.Hijacker),

 		Upgrade:    upgrade,

 		UseStdin:   httputils.BoolValue(r, "stdin"),

@@ -483,7 +483,7 @@ func (s *containerRouter) wsContainersAttach(ctx context.Context, w http.Respons

 	h := websocket.Handler(func(ws *websocket.Conn) {

 		defer ws.Close()

-		wsAttachWithLogsConfig := &daemon.ContainerWsAttachWithLogsConfig{

+		wsAttachWithLogsConfig := &backend.ContainerWsAttachWithLogsConfig{

 			InStream:   ws,

 			OutStream:  ws,

 			ErrStream:  ws,

new file mode 100644

@@ -0,0 +1,44 @@

+package image

+

+import (

+	"io"

+

+	"github.com/docker/docker/reference"

+	"github.com/docker/engine-api/types"

+	"github.com/docker/engine-api/types/container"

+	"github.com/docker/engine-api/types/registry"

+)

+

+// Backend is all the methods that need to be implemented

+// to provide image specific functionality.

+type Backend interface {

+	containerBackend

+	imageBackend

+	importExportBackend

+	registryBackend

+}

+

+type containerBackend interface {

+	Commit(name string, config *types.ContainerCommitConfig) (imageID string, err error)

+	Exists(containerName string) bool

+}

+

+type imageBackend interface {

+	ImageDelete(imageRef string, force, prune bool) ([]types.ImageDelete, error)

+	ImageHistory(imageName string) ([]*types.ImageHistory, error)

+	Images(filterArgs string, filter string, all bool) ([]*types.Image, error)

+	LookupImage(name string) (*types.ImageInspect, error)

+	TagImage(newTag reference.Named, imageName string) error

+}

+

+type importExportBackend interface {

+	LoadImage(inTar io.ReadCloser, outStream io.Writer) error

+	ImportImage(src string, newRef reference.Named, msg string, inConfig io.ReadCloser, outStream io.Writer, config *container.Config) error

+	ExportImage(names []string, outStream io.Writer) error

+}

+

+type registryBackend interface {

+	PullImage(ref reference.Named, metaHeaders map[string][]string, authConfig *types.AuthConfig, outStream io.Writer) error

+	PushImage(ref reference.Named, metaHeaders map[string][]string, authConfig *types.AuthConfig, outStream io.Writer) error

+	SearchRegistryForImages(term string, authConfig *types.AuthConfig, metaHeaders map[string][]string) (*registry.SearchResults, error)

+}

new file mode 100644

@@ -0,0 +1,44 @@

+package image

+

+import "github.com/docker/docker/api/server/router"

+

+// imageRouter is a router to talk with the image controller

+type imageRouter struct {

+	daemon Backend

+	routes []router.Route

+}

+

+// NewRouter initializes a new image router

+func NewRouter(daemon Backend) router.Router {

+	r := &imageRouter{

+		daemon: daemon,

+	}

+	r.initRoutes()

+	return r

+}

+

+// Routes returns the available routes to the image controller

+func (r *imageRouter) Routes() []router.Route {

+	return r.routes

+}

+

+// initRoutes initializes the routes in the image router

+func (r *imageRouter) initRoutes() {

+	r.routes = []router.Route{

+		// GET

+		router.NewGetRoute("/images/json", r.getImagesJSON),

+		router.NewGetRoute("/images/search", r.getImagesSearch),

+		router.NewGetRoute("/images/get", r.getImagesGet),

+		router.NewGetRoute("/images/{name:.*}/get", r.getImagesGet),

+		router.NewGetRoute("/images/{name:.*}/history", r.getImagesHistory),

+		router.NewGetRoute("/images/{name:.*}/json", r.getImagesByName),

+		// POST

+		router.NewPostRoute("/commit", r.postCommit),

+		router.NewPostRoute("/images/create", r.postImagesCreate),

+		router.NewPostRoute("/images/load", r.postImagesLoad),

+		router.NewPostRoute("/images/{name:.*}/push", r.postImagesPush),

+		router.NewPostRoute("/images/{name:.*}/tag", r.postImagesTag),

+		// DELETE

+		router.NewDeleteRoute("/images/{name:.*}", r.deleteImages),

+	}

+}

new file mode 100644

@@ -0,0 +1,399 @@

+package image

+

+import (

+	"encoding/base64"

+	"encoding/json"

+	"errors"

+	"fmt"

+	"io"

+	"net/http"

+	"net/url"

+	"strings"

+

+	"github.com/docker/distribution/digest"

+	"github.com/docker/distribution/registry/api/errcode"

+	"github.com/docker/docker/api/server/httputils"

+	"github.com/docker/docker/builder/dockerfile"

+	derr "github.com/docker/docker/errors"

+	"github.com/docker/docker/pkg/ioutils"

+	"github.com/docker/docker/pkg/streamformatter"

+	"github.com/docker/docker/reference"

+	"github.com/docker/docker/runconfig"

+	"github.com/docker/engine-api/types"

+	"github.com/docker/engine-api/types/container"

+	"golang.org/x/net/context"

+)

+

+func (s *imageRouter) postCommit(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	if err := httputils.CheckForJSON(r); err != nil {

+		return err

+	}

+

+	cname := r.Form.Get("container")

+

+	pause := httputils.BoolValue(r, "pause")

+	version := httputils.VersionFromContext(ctx)

+	if r.FormValue("pause") == "" && version.GreaterThanOrEqualTo("1.13") {

+		pause = true

+	}

+

+	c, _, _, err := runconfig.DecodeContainerConfig(r.Body)

+	if err != nil && err != io.EOF { //Do not fail if body is empty.

+		return err

+	}

+	if c == nil {

+		c = &container.Config{}

+	}

+

+	if !s.daemon.Exists(cname) {

+		return derr.ErrorCodeNoSuchContainer.WithArgs(cname)

+	}

+

+	newConfig, err := dockerfile.BuildFromConfig(c, r.Form["changes"])

+	if err != nil {

+		return err

+	}

+

+	commitCfg := &types.ContainerCommitConfig{

+		Pause:        pause,

+		Repo:         r.Form.Get("repo"),

+		Tag:          r.Form.Get("tag"),

+		Author:       r.Form.Get("author"),

+		Comment:      r.Form.Get("comment"),

+		Config:       newConfig,

+		MergeConfigs: true,

+	}

+

+	imgID, err := s.daemon.Commit(cname, commitCfg)

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusCreated, &types.ContainerCommitResponse{

+		ID: string(imgID),

+	})

+}

+

+// Creates an image from Pull or from Import

+func (s *imageRouter) postImagesCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	var (

+		image   = r.Form.Get("fromImage")

+		repo    = r.Form.Get("repo")

+		tag     = r.Form.Get("tag")

+		message = r.Form.Get("message")

+		err     error

+		output  = ioutils.NewWriteFlusher(w)

+	)

+	defer output.Close()

+

+	w.Header().Set("Content-Type", "application/json")

+

+	if image != "" { //pull

+		// Special case: "pull -a" may send an image name with a

+		// trailing :. This is ugly, but let's not break API

+		// compatibility.

+		image = strings.TrimSuffix(image, ":")

+

+		var ref reference.Named

+		ref, err = reference.ParseNamed(image)

+		if err == nil {

+			if tag != "" {

+				// The "tag" could actually be a digest.

+				var dgst digest.Digest

+				dgst, err = digest.ParseDigest(tag)

+				if err == nil {

+					ref, err = reference.WithDigest(ref, dgst)

+				} else {

+					ref, err = reference.WithTag(ref, tag)

+				}

+			}

+			if err == nil {

+				metaHeaders := map[string][]string{}

+				for k, v := range r.Header {

+					if strings.HasPrefix(k, "X-Meta-") {

+						metaHeaders[k] = v

+					}

+				}

+

+				authEncoded := r.Header.Get("X-Registry-Auth")

+				authConfig := &types.AuthConfig{}

+				if authEncoded != "" {

+					authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

+					if err := json.NewDecoder(authJSON).Decode(authConfig); err != nil {

+						// for a pull it is not an error if no auth was given

+						// to increase compatibility with the existing api it is defaulting to be empty

+						authConfig = &types.AuthConfig{}

+					}

+				}

+

+				err = s.daemon.PullImage(ref, metaHeaders, authConfig, output)

+			}

+		}

+		// Check the error from pulling an image to make sure the request

+		// was authorized. Modify the status if the request was

+		// unauthorized to respond with 401 rather than 500.

+		if err != nil && isAuthorizedError(err) {

+			err = errcode.ErrorCodeUnauthorized.WithMessage(fmt.Sprintf("Authentication is required: %s", err))

+		}

+	} else { //import

+		var newRef reference.Named

+		if repo != "" {

+			var err error

+			newRef, err = reference.ParseNamed(repo)

+			if err != nil {

+				return err

+			}

+

+			if _, isCanonical := newRef.(reference.Canonical); isCanonical {

+				return errors.New("cannot import digest reference")

+			}

+

+			if tag != "" {

+				newRef, err = reference.WithTag(newRef, tag)

+				if err != nil {

+					return err

+				}

+			}

+		}

+

+		src := r.Form.Get("fromSrc")

+

+		// 'err' MUST NOT be defined within this block, we need any error

+		// generated from the download to be available to the output

+		// stream processing below

+		var newConfig *container.Config

+		newConfig, err = dockerfile.BuildFromConfig(&container.Config{}, r.Form["changes"])

+		if err != nil {

+			return err

+		}

+

+		err = s.daemon.ImportImage(src, newRef, message, r.Body, output, newConfig)

+	}

+	if err != nil {

+		if !output.Flushed() {

+			return err

+		}

+		sf := streamformatter.NewJSONStreamFormatter()

+		output.Write(sf.FormatError(err))

+	}

+

+	return nil

+}

+

+func (s *imageRouter) postImagesPush(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	metaHeaders := map[string][]string{}

+	for k, v := range r.Header {

+		if strings.HasPrefix(k, "X-Meta-") {

+			metaHeaders[k] = v

+		}

+	}

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	authConfig := &types.AuthConfig{}

+

+	authEncoded := r.Header.Get("X-Registry-Auth")

+	if authEncoded != "" {

+		// the new format is to handle the authConfig as a header

+		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

+		if err := json.NewDecoder(authJSON).Decode(authConfig); err != nil {

+			// to increase compatibility to existing api it is defaulting to be empty

+			authConfig = &types.AuthConfig{}

+		}

+	} else {

+		// the old format is supported for compatibility if there was no authConfig header

+		if err := json.NewDecoder(r.Body).Decode(authConfig); err != nil {

+			return fmt.Errorf("Bad parameters and missing X-Registry-Auth: %v", err)

+		}

+	}

+

+	ref, err := reference.ParseNamed(vars["name"])

+	if err != nil {

+		return err

+	}

+	tag := r.Form.Get("tag")

+	if tag != "" {

+		// Push by digest is not supported, so only tags are supported.

+		ref, err = reference.WithTag(ref, tag)

+		if err != nil {

+			return err

+		}

+	}

+

+	output := ioutils.NewWriteFlusher(w)

+	defer output.Close()

+

+	w.Header().Set("Content-Type", "application/json")

+

+	if err := s.daemon.PushImage(ref, metaHeaders, authConfig, output); err != nil {

+		if !output.Flushed() {

+			return err

+		}

+		sf := streamformatter.NewJSONStreamFormatter()

+		output.Write(sf.FormatError(err))

+	}

+	return nil

+}

+

+func (s *imageRouter) getImagesGet(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	w.Header().Set("Content-Type", "application/x-tar")

+

+	output := ioutils.NewWriteFlusher(w)

+	defer output.Close()

+	var names []string

+	if name, ok := vars["name"]; ok {

+		names = []string{name}

+	} else {

+		names = r.Form["names"]

+	}

+

+	if err := s.daemon.ExportImage(names, output); err != nil {

+		if !output.Flushed() {

+			return err

+		}

+		sf := streamformatter.NewJSONStreamFormatter()

+		output.Write(sf.FormatError(err))

+	}

+	return nil

+}

+

+func (s *router) postImagesLoad(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	quiet := httputils.BoolValueOrDefault(r, "quiet", true)

+	w.Header().Set("Content-Type", "application/json")

+	return s.daemon.LoadImage(r.Body, w, quiet)

+}

+

+func (s *imageRouter) deleteImages(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	name := vars["name"]

+

+	if strings.TrimSpace(name) == "" {

+		return fmt.Errorf("image name cannot be blank")

+	}

+

+	force := httputils.BoolValue(r, "force")

+	prune := !httputils.BoolValue(r, "noprune")

+

+	list, err := s.daemon.ImageDelete(name, force, prune)

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, list)

+}

+

+func (s *imageRouter) getImagesByName(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	imageInspect, err := s.daemon.LookupImage(vars["name"])

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, imageInspect)

+}

+

+func (s *imageRouter) getImagesJSON(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+

+	// FIXME: The filter parameter could just be a match filter

+	images, err := s.daemon.Images(r.Form.Get("filters"), r.Form.Get("filter"), httputils.BoolValue(r, "all"))

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, images)

+}

+

+func (s *imageRouter) getImagesHistory(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	name := vars["name"]

+	history, err := s.daemon.ImageHistory(name)

+	if err != nil {

+		return err

+	}

+

+	return httputils.WriteJSON(w, http.StatusOK, history)

+}

+

+func (s *imageRouter) postImagesTag(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	repo := r.Form.Get("repo")

+	tag := r.Form.Get("tag")

+	newTag, err := reference.WithName(repo)

+	if err != nil {

+		return err

+	}

+	if tag != "" {

+		if newTag, err = reference.WithTag(newTag, tag); err != nil {

+			return err

+		}

+	}

+	if err := s.daemon.TagImage(newTag, vars["name"]); err != nil {

+		return err

+	}

+	w.WriteHeader(http.StatusCreated)

+	return nil

+}

+

+func (s *imageRouter) getImagesSearch(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	if err := httputils.ParseForm(r); err != nil {

+		return err

+	}

+	var (

+		config      *types.AuthConfig

+		authEncoded = r.Header.Get("X-Registry-Auth")

+		headers     = map[string][]string{}

+	)

+

+	if authEncoded != "" {

+		authJSON := base64.NewDecoder(base64.URLEncoding, strings.NewReader(authEncoded))

+		if err := json.NewDecoder(authJSON).Decode(&config); err != nil {

+			// for a search it is not an error if no auth was given

+			// to increase compatibility with the existing api it is defaulting to be empty

+			config = &types.AuthConfig{}

+		}

+	}

+	for k, v := range r.Header {

+		if strings.HasPrefix(k, "X-Meta-") {

+			headers[k] = v

+		}

+	}

+	query, err := s.daemon.SearchRegistryForImages(r.Form.Get("term"), config, headers)

+	if err != nil {

+		return err

+	}

+	return httputils.WriteJSON(w, http.StatusOK, query.Results)

+}

+

+func isAuthorizedError(err error) bool {

+	if urlError, ok := err.(*url.Error); ok {

+		err = urlError.Err

+	}

+

+	if dError, ok := err.(errcode.Error); ok {

+		if dError.ErrorCode() == errcode.ErrorCodeUnauthorized {

+			return true

+		}

+	}

+	return false

+}

new file mode 100644

@@ -0,0 +1,61 @@

+package router

+

+import "github.com/docker/docker/api/server/httputils"

+

+// localRoute defines an individual API route to connect

+// with the docker daemon. It implements Route.

+type localRoute struct {

+	method  string

+	path    string

+	handler httputils.APIFunc

+}

+

+// Handler returns the APIFunc to let the server wrap it in middlewares.

+func (l localRoute) Handler() httputils.APIFunc {

+	return l.handler

+}

+

+// Method returns the http method that the route responds to.

+func (l localRoute) Method() string {

+	return l.method

+}

+

+// Path returns the subpath where the route responds to.

+func (l localRoute) Path() string {

+	return l.path

+}

+

+// NewRoute initializes a new local route for the router.

+func NewRoute(method, path string, handler httputils.APIFunc) Route {

+	return localRoute{method, path, handler}

+}

+

+// NewGetRoute initializes a new route with the http method GET.

+func NewGetRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("GET", path, handler)

+}

+

+// NewPostRoute initializes a new route with the http method POST.

+func NewPostRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("POST", path, handler)

+}

+

+// NewPutRoute initializes a new route with the http method PUT.

+func NewPutRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("PUT", path, handler)

+}

+

+// NewDeleteRoute initializes a new route with the http method DELETE.

+func NewDeleteRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("DELETE", path, handler)

+}

+

+// NewOptionsRoute initializes a new route with the http method OPTIONS.

+func NewOptionsRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("OPTIONS", path, handler)

+}

+

+// NewHeadRoute initializes a new route with the http method HEAD.

+func NewHeadRoute(path string, handler httputils.APIFunc) Route {

+	return NewRoute("HEAD", path, handler)

+}

deleted file mode 100644

@@ -1,399 +0,0 @@

-package local

-

-import (

-	"encoding/base64"

-	"encoding/json"

-	"errors"

-	"fmt"

-	"io"

-	"net/http"

-	"net/url"

-	"strings"

-

-	"github.com/docker/distribution/digest"

-	"github.com/docker/distribution/registry/api/errcode"

-	"github.com/docker/docker/api/server/httputils"

-	"github.com/docker/docker/builder/dockerfile"

-	derr "github.com/docker/docker/errors"

-	"github.com/docker/docker/pkg/ioutils"

-	"github.com/docker/docker/pkg/streamformatter"

-	"github.com/docker/docker/reference"

-	"github.com/docker/docker/runconfig"

-	"github.com/docker/engine-api/types"

-	"github.com/docker/engine-api/types/container"

-	"golang.org/x/net/context"

-)

-

-func (s *router) postCommit(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := httputils.ParseForm(r); err != nil {

-		return err

-	}

-

-	if err := httputils.CheckForJSON(r); err != nil {

-		return err

-	}

-

-	cname := r.Form.Get("container")

-

-	pause := httputils.BoolValue(r, "pause")

-	version := httputils.VersionFromContext(ctx)

-	if r.FormValue("pause") == "" && version.GreaterThanOrEqualTo("1.13") {

-		pause = true

-	}

-

-	c, _, _, err := runconfig.DecodeContainerConfig(r.Body)

-	if err != nil && err != io.EOF { //Do not fail if body is empty.

-		return err

-	}

-	if c == nil {

-		c = &container.Config{}

-	}

-

-	if !s.daemon.Exists(cname) {

-		return derr.ErrorCodeNoSuchContainer.WithArgs(cname)

-	}

-

-	newConfig, err := dockerfile.BuildFromConfig(c, r.Form["changes"])

-	if err != nil {

-		return err

-	}

-

-	commitCfg := &types.ContainerCommitConfig{

-		Pause:        pause,

-		Repo:         r.Form.Get("repo"),

-		Tag:          r.Form.Get("tag"),

-		Author:       r.Form.Get("author"),

-		Comment:      r.Form.Get("comment"),

-		Config:       newConfig,

-		MergeConfigs: true,

-	}

-

-	imgID, err := s.daemon.Commit(cname, commitCfg)

-	if err != nil {

-		return err

-	}

-

-	return httputils.WriteJSON(w, http.StatusCreated, &types.ContainerCommitResponse{

-		ID: string(imgID),

-	})

-}

-

-// Creates an image from Pull or from Import

-func (s *router) postImagesCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

-	if err := httputils.ParseForm(r); err != nil {

-		return err

-	}

-

-	var (

-		image   = r.Form.Get("fromImage")

-		repo    = r.Form.Get("repo")

-		tag     = r.Form.Get("tag")

-		message = r.Form.Get("message")

-		err     error

-		output  = ioutils.NewWriteFlusher(w)

-	)

-	defer output.Close()

-

-	w.Header().Set("Content-Type", "application/json")

-

-	if image != "" { //pull