@@ -231,24 +231,6 @@ func (s *DockerDaemonSuite) TestVolumePlugin(c *check.C) {

 	c.Assert(err, checker.IsNil, check.Commentf(out))

 }

-func (s *DockerDaemonSuite) TestGraphdriverPlugin(c *check.C) {

-	testRequires(c, Network, IsAmd64, DaemonIsLinux, overlay2Supported, ExperimentalDaemon)

-

-	s.d.Start(c)

-

-	// install the plugin

-	plugin := "cpuguy83/docker-overlay2-graphdriver-plugin"

-	out, err := s.d.Cmd("plugin", "install", "--grant-all-permissions", plugin)

-	c.Assert(err, checker.IsNil, check.Commentf(out))

-

-	// restart the daemon with the plugin set as the storage driver

-	s.d.Restart(c, "-s", plugin, "--storage-opt", "overlay2.override_kernel_check=1")

-

-	// run a container

-	out, err = s.d.Cmd("run", "--rm", "busybox", "true") // this will pull busybox using the plugin

-	c.Assert(err, checker.IsNil, check.Commentf(out))

-}

-

 func (s *DockerDaemonSuite) TestPluginVolumeRemoveOnRestart(c *check.C) {

 	testRequires(c, DaemonIsLinux, Network, IsAmd64)

deleted file mode 100644

@@ -1,406 +0,0 @@

-// +build !windows

-

-package main

-

-import (

-	"encoding/json"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"net/http"

-	"net/http/httptest"

-	"os"

-	"strings"

-

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

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

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

-	testdaemon "github.com/docker/docker/internal/test/daemon"

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

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

-	"github.com/go-check/check"

-)

-

-func init() {

-	check.Suite(&DockerExternalGraphdriverSuite{

-		ds: &DockerSuite{},

-	})

-}

-

-type DockerExternalGraphdriverSuite struct {

-	server  *httptest.Server

-	jserver *httptest.Server

-	ds      *DockerSuite

-	d       *daemon.Daemon

-	ec      map[string]*graphEventsCounter

-}

-

-type graphEventsCounter struct {

-	activations int

-	creations   int

-	removals    int

-	gets        int

-	puts        int

-	stats       int

-	cleanups    int

-	exists      int

-	init        int

-	metadata    int

-	diff        int

-	applydiff   int

-	changes     int

-	diffsize    int

-}

-

-func (s *DockerExternalGraphdriverSuite) SetUpTest(c *check.C) {

-	s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))

-}

-

-func (s *DockerExternalGraphdriverSuite) OnTimeout(c *check.C) {

-	s.d.DumpStackAndQuit()

-}

-

-func (s *DockerExternalGraphdriverSuite) TearDownTest(c *check.C) {

-	if s.d != nil {

-		s.d.Stop(c)

-		s.ds.TearDownTest(c)

-	}

-}

-

-func (s *DockerExternalGraphdriverSuite) SetUpSuite(c *check.C) {

-	s.ec = make(map[string]*graphEventsCounter)

-	s.setUpPluginViaSpecFile(c)

-	s.setUpPluginViaJSONFile(c)

-}

-

-func (s *DockerExternalGraphdriverSuite) setUpPluginViaSpecFile(c *check.C) {

-	mux := http.NewServeMux()

-	s.server = httptest.NewServer(mux)

-

-	s.setUpPlugin(c, "test-external-graph-driver", "spec", mux, []byte(s.server.URL))

-}

-

-func (s *DockerExternalGraphdriverSuite) setUpPluginViaJSONFile(c *check.C) {

-	mux := http.NewServeMux()

-	s.jserver = httptest.NewServer(mux)

-

-	p := plugins.NewLocalPlugin("json-external-graph-driver", s.jserver.URL)

-	b, err := json.Marshal(p)

-	c.Assert(err, check.IsNil)

-

-	s.setUpPlugin(c, "json-external-graph-driver", "json", mux, b)

-}

-

-func (s *DockerExternalGraphdriverSuite) setUpPlugin(c *check.C, name string, ext string, mux *http.ServeMux, b []byte) {

-	type graphDriverRequest struct {

-		ID         string `json:",omitempty"`

-		Parent     string `json:",omitempty"`

-		MountLabel string `json:",omitempty"`

-		ReadOnly   bool   `json:",omitempty"`

-	}

-

-	type graphDriverResponse struct {

-		Err      error             `json:",omitempty"`

-		Dir      string            `json:",omitempty"`

-		Exists   bool              `json:",omitempty"`

-		Status   [][2]string       `json:",omitempty"`

-		Metadata map[string]string `json:",omitempty"`

-		Changes  []archive.Change  `json:",omitempty"`

-		Size     int64             `json:",omitempty"`

-	}

-

-	respond := func(w http.ResponseWriter, data interface{}) {

-		w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")

-		switch t := data.(type) {

-		case error:

-			fmt.Fprintln(w, fmt.Sprintf(`{"Err": %q}`, t.Error()))

-		case string:

-			fmt.Fprintln(w, t)

-		default:

-			json.NewEncoder(w).Encode(&data)

-		}

-	}

-

-	decReq := func(b io.ReadCloser, out interface{}, w http.ResponseWriter) error {

-		defer b.Close()

-		if err := json.NewDecoder(b).Decode(&out); err != nil {

-			http.Error(w, fmt.Sprintf("error decoding json: %s", err.Error()), 500)

-		}

-		return nil

-	}

-

-	base, err := ioutil.TempDir("", name)

-	c.Assert(err, check.IsNil)

-	vfsProto, err := vfs.Init(base, []string{}, nil, nil)

-	c.Assert(err, check.IsNil, check.Commentf("error initializing graph driver"))

-	driver := graphdriver.NewNaiveDiffDriver(vfsProto, nil, nil)

-

-	s.ec[ext] = &graphEventsCounter{}

-	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].activations++

-		respond(w, `{"Implements": ["GraphDriver"]}`)

-	})

-

-	mux.HandleFunc("/GraphDriver.Init", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].init++

-		respond(w, "{}")

-	})

-

-	mux.HandleFunc("/GraphDriver.CreateReadWrite", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].creations++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-		if err := driver.CreateReadWrite(req.ID, req.Parent, nil); err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, "{}")

-	})

-

-	mux.HandleFunc("/GraphDriver.Create", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].creations++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-		if err := driver.Create(req.ID, req.Parent, nil); err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, "{}")

-	})

-

-	mux.HandleFunc("/GraphDriver.Remove", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].removals++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		if err := driver.Remove(req.ID); err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, "{}")

-	})

-

-	mux.HandleFunc("/GraphDriver.Get", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].gets++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		// TODO @gupta-ak: Figure out what to do here.

-		dir, err := driver.Get(req.ID, req.MountLabel)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, &graphDriverResponse{Dir: dir.Path()})

-	})

-

-	mux.HandleFunc("/GraphDriver.Put", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].puts++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		if err := driver.Put(req.ID); err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, "{}")

-	})

-

-	mux.HandleFunc("/GraphDriver.Exists", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].exists++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-		respond(w, &graphDriverResponse{Exists: driver.Exists(req.ID)})

-	})

-

-	mux.HandleFunc("/GraphDriver.Status", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].stats++

-		respond(w, &graphDriverResponse{Status: driver.Status()})

-	})

-

-	mux.HandleFunc("/GraphDriver.Cleanup", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].cleanups++

-		err := driver.Cleanup()

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, `{}`)

-	})

-

-	mux.HandleFunc("/GraphDriver.GetMetadata", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].metadata++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		data, err := driver.GetMetadata(req.ID)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, &graphDriverResponse{Metadata: data})

-	})

-

-	mux.HandleFunc("/GraphDriver.Diff", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].diff++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		diff, err := driver.Diff(req.ID, req.Parent)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		io.Copy(w, diff)

-	})

-

-	mux.HandleFunc("/GraphDriver.Changes", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].changes++

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		changes, err := driver.Changes(req.ID, req.Parent)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, &graphDriverResponse{Changes: changes})

-	})

-

-	mux.HandleFunc("/GraphDriver.ApplyDiff", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].applydiff++

-		diff := r.Body

-		defer r.Body.Close()

-

-		id := r.URL.Query().Get("id")

-		parent := r.URL.Query().Get("parent")

-

-		if id == "" {

-			http.Error(w, fmt.Sprintf("missing id"), 409)

-		}

-

-		size, err := driver.ApplyDiff(id, parent, diff)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, &graphDriverResponse{Size: size})

-	})

-

-	mux.HandleFunc("/GraphDriver.DiffSize", func(w http.ResponseWriter, r *http.Request) {

-		s.ec[ext].diffsize++

-

-		var req graphDriverRequest

-		if err := decReq(r.Body, &req, w); err != nil {

-			return

-		}

-

-		size, err := driver.DiffSize(req.ID, req.Parent)

-		if err != nil {

-			respond(w, err)

-			return

-		}

-		respond(w, &graphDriverResponse{Size: size})

-	})

-

-	err = os.MkdirAll("/etc/docker/plugins", 0755)

-	c.Assert(err, check.IsNil, check.Commentf("error creating /etc/docker/plugins"))

-

-	specFile := "/etc/docker/plugins/" + name + "." + ext

-	err = ioutil.WriteFile(specFile, b, 0644)

-	c.Assert(err, check.IsNil, check.Commentf("error writing to %s", specFile))

-}

-

-func (s *DockerExternalGraphdriverSuite) TearDownSuite(c *check.C) {

-	s.server.Close()

-	s.jserver.Close()

-

-	err := os.RemoveAll("/etc/docker/plugins")

-	c.Assert(err, check.IsNil, check.Commentf("error removing /etc/docker/plugins"))

-}

-

-func (s *DockerExternalGraphdriverSuite) TestExternalGraphDriver(c *check.C) {

-	testRequires(c, ExperimentalDaemon, SameHostDaemon)

-

-	s.testExternalGraphDriver("test-external-graph-driver", "spec", c)

-	s.testExternalGraphDriver("json-external-graph-driver", "json", c)

-}

-

-func (s *DockerExternalGraphdriverSuite) testExternalGraphDriver(name string, ext string, c *check.C) {

-	s.d.StartWithBusybox(c, "-s", name)

-

-	out, err := s.d.Cmd("run", "--name=graphtest", "busybox", "sh", "-c", "echo hello > /hello")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-

-	s.d.Restart(c, "-s", name)

-

-	out, err = s.d.Cmd("inspect", "--format={{.GraphDriver.Name}}", "graphtest")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-	c.Assert(strings.TrimSpace(out), check.Equals, name)

-

-	out, err = s.d.Cmd("diff", "graphtest")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-	c.Assert(strings.Contains(out, "A /hello"), check.Equals, true, check.Commentf("diff output: %s", out))

-

-	out, err = s.d.Cmd("rm", "-f", "graphtest")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-

-	out, err = s.d.Cmd("info")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-

-	s.d.Stop(c)

-

-	// Don't check s.ec.exists, because the daemon no longer calls the

-	// Exists function.

-	c.Assert(s.ec[ext].activations, check.Equals, 2)

-	c.Assert(s.ec[ext].init, check.Equals, 2)

-	c.Assert(s.ec[ext].creations >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].removals >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].gets >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].puts >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].stats, check.Equals, 5)

-	c.Assert(s.ec[ext].cleanups, check.Equals, 2)

-	c.Assert(s.ec[ext].applydiff >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].changes, check.Equals, 1)

-	c.Assert(s.ec[ext].diffsize, check.Equals, 0)

-	c.Assert(s.ec[ext].diff, check.Equals, 0)

-	c.Assert(s.ec[ext].metadata, check.Equals, 1)

-}

-

-func (s *DockerExternalGraphdriverSuite) TestExternalGraphDriverPull(c *check.C) {

-	testRequires(c, Network, ExperimentalDaemon, SameHostDaemon)

-

-	s.d.Start(c)

-

-	out, err := s.d.Cmd("pull", "busybox:latest")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-

-	out, err = s.d.Cmd("run", "-d", "busybox", "top")

-	c.Assert(err, check.IsNil, check.Commentf(out))

-}

@@ -5,6 +5,9 @@ import (

 	"strings"

 	"testing"

 	"time"

+

+	"github.com/docker/docker/pkg/parsers/kernel"

+	"github.com/gotestyourself/gotestyourself/icmd"

 )

 // HasHubConnectivity checks to see if https://hub.docker.com is

@@ -24,3 +27,26 @@ func HasHubConnectivity(t *testing.T) bool {

 	}

 	return err == nil

 }

+

+func overlayFSSupported() bool {

+	result := icmd.RunCommand("/bin/sh", "-c", "cat /proc/filesystems")

+	if result.Error != nil {

+		return false

+	}

+	return strings.Contains(result.Combined(), "overlay\n")

+}

+

+// Overlay2Supported returns true if the current system supports overlay2 as graphdriver

+func Overlay2Supported(kernelVersion string) bool {

+	if !overlayFSSupported() {

+		return false

+	}

+

+	daemonV, err := kernel.ParseRelease(kernelVersion)

+	if err != nil {

+		return false

+	}

+	requiredV := kernel.VersionInfo{Kernel: 4}

+	return kernel.CompareKernelVersion(*daemonV, requiredV) > -1

+

+}

new file mode 100644

@@ -0,0 +1,462 @@

+package graphdriver

+

+import (

+	"context"

+	"encoding/json"

+	"fmt"

+	"io"

+	"io/ioutil"

+	"net/http"

+	"net/http/httptest"

+	"os"

+	"runtime"

+	"testing"

+

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

+	containertypes "github.com/docker/docker/api/types/container"

+	"github.com/docker/docker/client"

+	"github.com/docker/docker/daemon/graphdriver"

+	"github.com/docker/docker/daemon/graphdriver/vfs"

+	"github.com/docker/docker/integration/internal/container"

+	"github.com/docker/docker/integration/internal/requirement"

+	"github.com/docker/docker/internal/test/daemon"

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

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

+	"github.com/gotestyourself/gotestyourself/assert"

+	is "github.com/gotestyourself/gotestyourself/assert/cmp"

+	"github.com/gotestyourself/gotestyourself/skip"

+)

+

+type graphEventsCounter struct {

+	activations int

+	creations   int

+	removals    int

+	gets        int

+	puts        int

+	stats       int

+	cleanups    int

+	exists      int

+	init        int

+	metadata    int

+	diff        int

+	applydiff   int

+	changes     int

+	diffsize    int

+}

+

+func TestExternalGraphDriver(t *testing.T) {

+	skip.If(t, runtime.GOOS == "windows")

+	skip.If(t, testEnv.IsRemoteDaemon(), "cannot run daemon when remote daemon")

+	skip.If(t, !requirement.HasHubConnectivity(t))

+

+	// Setup plugin(s)

+	ec := make(map[string]*graphEventsCounter)

+	sserver := setupPluginViaSpecFile(t, ec)

+	jserver := setupPluginViaJSONFile(t, ec)

+	// Create daemon

+	d := daemon.New(t, daemon.WithExperimental)

+	c := d.NewClientT(t)

+

+	for _, tc := range []struct {

+		name string

+		test func(client.APIClient, *daemon.Daemon) func(*testing.T)

+	}{

+		{

+			name: "json",

+			test: testExternalGraphDriver("json", ec),

+		},

+		{

+			name: "spec",

+			test: testExternalGraphDriver("spec", ec),

+		},

+		{

+			name: "pull",

+			test: testGraphDriverPull,

+		},

+	} {

+		t.Run(tc.name, tc.test(c, d))

+	}

+

+	sserver.Close()

+	jserver.Close()

+	err := os.RemoveAll("/etc/docker/plugins")

+	assert.NilError(t, err)

+}

+

+func setupPluginViaSpecFile(t *testing.T, ec map[string]*graphEventsCounter) *httptest.Server {

+	mux := http.NewServeMux()

+	server := httptest.NewServer(mux)

+

+	setupPlugin(t, ec, "spec", mux, []byte(server.URL))

+

+	return server

+}

+

+func setupPluginViaJSONFile(t *testing.T, ec map[string]*graphEventsCounter) *httptest.Server {

+	mux := http.NewServeMux()

+	server := httptest.NewServer(mux)

+

+	p := plugins.NewLocalPlugin("json-external-graph-driver", server.URL)

+	b, err := json.Marshal(p)

+	assert.NilError(t, err)

+

+	setupPlugin(t, ec, "json", mux, b)

+

+	return server

+}

+

+func setupPlugin(t *testing.T, ec map[string]*graphEventsCounter, ext string, mux *http.ServeMux, b []byte) {

+	name := fmt.Sprintf("%s-external-graph-driver", ext)

+	type graphDriverRequest struct {

+		ID         string `json:",omitempty"`

+		Parent     string `json:",omitempty"`

+		MountLabel string `json:",omitempty"`

+		ReadOnly   bool   `json:",omitempty"`

+	}

+

+	type graphDriverResponse struct {

+		Err      error             `json:",omitempty"`

+		Dir      string            `json:",omitempty"`

+		Exists   bool              `json:",omitempty"`

+		Status   [][2]string       `json:",omitempty"`

+		Metadata map[string]string `json:",omitempty"`

+		Changes  []archive.Change  `json:",omitempty"`

+		Size     int64             `json:",omitempty"`

+	}

+

+	respond := func(w http.ResponseWriter, data interface{}) {

+		w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")

+		switch t := data.(type) {

+		case error:

+			fmt.Fprintln(w, fmt.Sprintf(`{"Err": %q}`, t.Error()))

+		case string:

+			fmt.Fprintln(w, t)

+		default:

+			json.NewEncoder(w).Encode(&data)

+		}

+	}

+

+	decReq := func(b io.ReadCloser, out interface{}, w http.ResponseWriter) error {

+		defer b.Close()

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

+			http.Error(w, fmt.Sprintf("error decoding json: %s", err.Error()), 500)

+		}

+		return nil

+	}

+

+	base, err := ioutil.TempDir("", name)

+	assert.NilError(t, err)

+	vfsProto, err := vfs.Init(base, []string{}, nil, nil)

+	assert.NilError(t, err, "error initializing graph driver")

+	driver := graphdriver.NewNaiveDiffDriver(vfsProto, nil, nil)

+

+	ec[ext] = &graphEventsCounter{}

+	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].activations++

+		respond(w, `{"Implements": ["GraphDriver"]}`)

+	})

+

+	mux.HandleFunc("/GraphDriver.Init", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].init++

+		respond(w, "{}")

+	})

+

+	mux.HandleFunc("/GraphDriver.CreateReadWrite", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].creations++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+		if err := driver.CreateReadWrite(req.ID, req.Parent, nil); err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, "{}")

+	})

+

+	mux.HandleFunc("/GraphDriver.Create", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].creations++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+		if err := driver.Create(req.ID, req.Parent, nil); err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, "{}")

+	})

+

+	mux.HandleFunc("/GraphDriver.Remove", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].removals++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		if err := driver.Remove(req.ID); err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, "{}")

+	})

+

+	mux.HandleFunc("/GraphDriver.Get", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].gets++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		// TODO @gupta-ak: Figure out what to do here.

+		dir, err := driver.Get(req.ID, req.MountLabel)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, &graphDriverResponse{Dir: dir.Path()})

+	})

+

+	mux.HandleFunc("/GraphDriver.Put", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].puts++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		if err := driver.Put(req.ID); err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, "{}")

+	})

+

+	mux.HandleFunc("/GraphDriver.Exists", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].exists++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+		respond(w, &graphDriverResponse{Exists: driver.Exists(req.ID)})

+	})

+

+	mux.HandleFunc("/GraphDriver.Status", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].stats++

+		respond(w, &graphDriverResponse{Status: driver.Status()})

+	})

+

+	mux.HandleFunc("/GraphDriver.Cleanup", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].cleanups++

+		err := driver.Cleanup()

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, `{}`)

+	})

+

+	mux.HandleFunc("/GraphDriver.GetMetadata", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].metadata++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		data, err := driver.GetMetadata(req.ID)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, &graphDriverResponse{Metadata: data})

+	})

+

+	mux.HandleFunc("/GraphDriver.Diff", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].diff++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		diff, err := driver.Diff(req.ID, req.Parent)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		io.Copy(w, diff)

+	})

+

+	mux.HandleFunc("/GraphDriver.Changes", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].changes++

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		changes, err := driver.Changes(req.ID, req.Parent)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, &graphDriverResponse{Changes: changes})

+	})

+

+	mux.HandleFunc("/GraphDriver.ApplyDiff", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].applydiff++

+		diff := r.Body

+		defer r.Body.Close()

+

+		id := r.URL.Query().Get("id")

+		parent := r.URL.Query().Get("parent")

+

+		if id == "" {

+			http.Error(w, fmt.Sprintf("missing id"), 409)

+		}

+

+		size, err := driver.ApplyDiff(id, parent, diff)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, &graphDriverResponse{Size: size})

+	})

+

+	mux.HandleFunc("/GraphDriver.DiffSize", func(w http.ResponseWriter, r *http.Request) {

+		ec[ext].diffsize++

+

+		var req graphDriverRequest

+		if err := decReq(r.Body, &req, w); err != nil {

+			return

+		}

+

+		size, err := driver.DiffSize(req.ID, req.Parent)

+		if err != nil {

+			respond(w, err)

+			return

+		}

+		respond(w, &graphDriverResponse{Size: size})

+	})

+

+	err = os.MkdirAll("/etc/docker/plugins", 0755)

+	assert.NilError(t, err)

+

+	specFile := "/etc/docker/plugins/" + name + "." + ext

+	err = ioutil.WriteFile(specFile, b, 0644)

+	assert.NilError(t, err)

+}

+

+func testExternalGraphDriver(ext string, ec map[string]*graphEventsCounter) func(client.APIClient, *daemon.Daemon) func(*testing.T) {

+	return func(c client.APIClient, d *daemon.Daemon) func(*testing.T) {

+		return func(t *testing.T) {

+			driverName := fmt.Sprintf("%s-external-graph-driver", ext)

+			d.StartWithBusybox(t, "-s", driverName)

+

+			ctx := context.Background()

+

+			testGraphDriver(t, c, ctx, driverName, func(t *testing.T) {

+				d.Restart(t, "-s", driverName)

+			})

+

+			_, err := c.Info(ctx)

+			assert.NilError(t, err)

+

+			d.Stop(t)

+

+			// Don't check ec.exists, because the daemon no longer calls the

+			// Exists function.

+			assert.Check(t, is.Equal(ec[ext].activations, 2))

+			assert.Check(t, is.Equal(ec[ext].init, 2))

+			assert.Check(t, ec[ext].creations >= 1)

+			assert.Check(t, ec[ext].removals >= 1)

+			assert.Check(t, ec[ext].gets >= 1)

+			assert.Check(t, ec[ext].puts >= 1)

+			assert.Check(t, is.Equal(ec[ext].stats, 5))

+			assert.Check(t, is.Equal(ec[ext].cleanups, 2))

+			assert.Check(t, ec[ext].applydiff >= 1)

+			assert.Check(t, is.Equal(ec[ext].changes, 1))

+			assert.Check(t, is.Equal(ec[ext].diffsize, 0))

+			assert.Check(t, is.Equal(ec[ext].diff, 0))

+			assert.Check(t, is.Equal(ec[ext].metadata, 1))

+		}

+	}

+}

+

+func testGraphDriverPull(c client.APIClient, d *daemon.Daemon) func(*testing.T) {

+	return func(t *testing.T) {

+		d.Start(t)

+		defer d.Stop(t)

+		ctx := context.Background()

+

+		r, err := c.ImagePull(ctx, "busybox:latest", types.ImagePullOptions{})

+		assert.NilError(t, err)

+		_, err = io.Copy(ioutil.Discard, r)

+		assert.NilError(t, err)

+

+		container.Run(t, ctx, c, container.WithImage("busybox:latest"))

+	}

+}

+

+func TestGraphdriverPluginV2(t *testing.T) {