@@ -1154,7 +1154,6 @@ func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.S

 			GraphDriver:               driverName,

 			GraphDriverOptions:        cfgStore.GraphOptions,

 			IDMapping:                 idMapping,

-			PluginGetter:              d.PluginStore,

 			ExperimentalEnabled:       cfgStore.Experimental,

 		})

 		if err != nil {

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

 	"github.com/containerd/log"

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

 	"github.com/docker/docker/pkg/idtools"

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

 	"github.com/pkg/errors"

 	"github.com/vbatts/tar-split/tar/storage"

 )

@@ -158,16 +157,17 @@ func Register(name string, initFunc InitFunc) error {

 }

 // GetDriver initializes and returns the registered driver

-func GetDriver(name string, pg plugingetter.PluginGetter, config Options) (Driver, error) {

+func GetDriver(name string, config Options) (Driver, error) {

 	if initFunc, exists := drivers[name]; exists {

 		return initFunc(filepath.Join(config.Root, name), config.DriverOptions, config.IDMap)

 	}

+	log.G(context.TODO()).WithFields(log.Fields{"driver": name, "home-dir": config.Root}).Error("Failed to GetDriver graph")

-	pluginDriver, err := lookupPlugin(name, pg, config)

-	if err == nil {

-		return pluginDriver, nil

+	// TODO(thaJeztah): remove in next release.

+	if config.ExperimentalEnabled && os.Getenv("DOCKERD_DEPRECATED_GRAPHDRIVER_PLUGINS") != "" {

+		return nil, fmt.Errorf("DEPRECATED: Support for experimental graphdriver plugins has been removed. See https://docs.docker.com/go/deprecated/")

 	}

-	log.G(context.TODO()).WithError(err).WithField("driver", name).WithField("home-dir", config.Root).Error("Failed to GetDriver graph")

+

 	return nil, ErrNotSupported

 }

@@ -189,14 +189,14 @@ type Options struct {

 }

 // New creates the driver and initializes it at the specified root.

-func New(name string, pg plugingetter.PluginGetter, config Options) (Driver, error) {

+func New(name string, config Options) (Driver, error) {

 	ctx := context.TODO()

 	if name != "" {

 		log.G(ctx).Infof("[graphdriver] trying configured driver: %s", name)

 		if err := checkRemoved(name); err != nil {

 			return nil, err

 		}

-		return GetDriver(name, pg, config)

+		return GetDriver(name, config)

 	}

 	// Guess for prior driver

@@ -34,7 +34,7 @@ func newDriver(t testing.TB, name string, options []string) *Driver {

 	assert.NilError(t, err)

 	assert.NilError(t, os.MkdirAll(root, 0o755))

-	d, err := graphdriver.GetDriver(name, nil, graphdriver.Options{DriverOptions: options, Root: root})

+	d, err := graphdriver.GetDriver(name, graphdriver.Options{DriverOptions: options, Root: root})

 	if err != nil {

 		t.Logf("graphdriver: %v\n", err)

 		if graphdriver.IsDriverNotSupported(err) {

deleted file mode 100644

@@ -1,59 +0,0 @@

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

-

-import (

-	"fmt"

-	"os"

-	"path/filepath"

-

-	"github.com/docker/docker/errdefs"

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

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

-	v2 "github.com/docker/docker/plugin/v2"

-	"github.com/pkg/errors"

-)

-

-func lookupPlugin(name string, pg plugingetter.PluginGetter, config Options) (Driver, error) {

-	if os.Getenv("DOCKERD_DEPRECATED_GRAPHDRIVER_PLUGINS") == "" {

-		return nil, fmt.Errorf("DEPRECATED: Experimental graphdriver plugins are deprecated, and disabled by default. This feature will be removed in the next release. See https://docs.docker.com/go/deprecated/")

-	}

-	if !config.ExperimentalEnabled {

-		return nil, fmt.Errorf("graphdriver plugins are only supported with experimental mode")

-	}

-	pl, err := pg.Get(name, "GraphDriver", plugingetter.Acquire)

-	if err != nil {

-		return nil, fmt.Errorf("Error looking up graphdriver plugin %s: %v", name, err)

-	}

-	return newPluginDriver(name, pl, config)

-}

-

-func newPluginDriver(name string, pl plugingetter.CompatPlugin, config Options) (Driver, error) {

-	home := config.Root

-	if !pl.IsV1() {

-		if p, ok := pl.(*v2.Plugin); ok {

-			if p.PluginObj.Config.PropagatedMount != "" {

-				home = p.PluginObj.Config.PropagatedMount

-			}

-		}

-	}

-

-	var proxy *graphDriverProxy

-

-	switch pt := pl.(type) {

-	case plugingetter.PluginWithV1Client:

-		proxy = &graphDriverProxy{name, pl, Capabilities{}, pt.Client()}

-	case plugingetter.PluginAddr:

-		if pt.Protocol() != plugins.ProtocolSchemeHTTPV1 {

-			return nil, errors.Errorf("plugin protocol not supported: %s", pt.Protocol())

-		}

-		addr := pt.Addr()

-		client, err := plugins.NewClientWithTimeout(addr.Network()+"://"+addr.String(), nil, pt.Timeout())

-		if err != nil {

-			return nil, errors.Wrap(err, "error creating plugin client")

-		}

-		proxy = &graphDriverProxy{name, pl, Capabilities{}, client}

-	default:

-		return nil, errdefs.System(errors.Errorf("got unknown plugin type %T", pt))

-	}

-

-	return proxy, proxy.Init(filepath.Join(home, name), config.DriverOptions, config.IDMap)

-}

deleted file mode 100644

@@ -1,261 +0,0 @@

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

-

-import (

-	"errors"

-	"fmt"

-	"io"

-

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

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

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

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

-)

-

-type graphDriverProxy struct {

-	name   string

-	p      plugingetter.CompatPlugin

-	caps   Capabilities

-	client *plugins.Client

-}

-

-type graphDriverRequest struct {

-	ID         string            `json:",omitempty"`

-	Parent     string            `json:",omitempty"`

-	MountLabel string            `json:",omitempty"`

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

-}

-

-type graphDriverResponse struct {

-	Err          string            `json:",omitempty"`

-	Dir          string            `json:",omitempty"`

-	Exists       bool              `json:",omitempty"`

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

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

-	Size         int64             `json:",omitempty"`

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

-	Capabilities Capabilities      `json:",omitempty"`

-}

-

-type graphDriverInitRequest struct {

-	Home string

-	Opts []string `json:"Opts"`

-	idtools.IdentityMapping

-}

-

-func (d *graphDriverProxy) Init(home string, opts []string, idMap idtools.IdentityMapping) error {

-	if !d.p.IsV1() {

-		if cp, ok := d.p.(plugingetter.CountedPlugin); ok {

-			// always acquire here, it will be cleaned up on daemon shutdown

-			cp.Acquire()

-		}

-	}

-	args := &graphDriverInitRequest{

-		Home:            home,

-		Opts:            opts,

-		IdentityMapping: idMap,

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Init", args, &ret); err != nil {

-		return err

-	}

-	if ret.Err != "" {

-		return errors.New(ret.Err)

-	}

-	caps, err := d.fetchCaps()

-	if err != nil {

-		return err

-	}

-	d.caps = caps

-	return nil

-}

-

-func (d *graphDriverProxy) fetchCaps() (Capabilities, error) {

-	args := &graphDriverRequest{}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Capabilities", args, &ret); err != nil {

-		if !plugins.IsNotFound(err) {

-			return Capabilities{}, err

-		}

-	}

-	return ret.Capabilities, nil

-}

-

-func (d *graphDriverProxy) String() string {

-	return d.name

-}

-

-func (d *graphDriverProxy) Capabilities() Capabilities {

-	return d.caps

-}

-

-func (d *graphDriverProxy) CreateReadWrite(id, parent string, opts *CreateOpts) error {

-	return d.create("GraphDriver.CreateReadWrite", id, parent, opts)

-}

-

-func (d *graphDriverProxy) Create(id, parent string, opts *CreateOpts) error {

-	return d.create("GraphDriver.Create", id, parent, opts)

-}

-

-func (d *graphDriverProxy) create(method, id, parent string, opts *CreateOpts) error {

-	args := &graphDriverRequest{

-		ID:     id,

-		Parent: parent,

-	}

-	if opts != nil {

-		args.MountLabel = opts.MountLabel

-		args.StorageOpt = opts.StorageOpt

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call(method, args, &ret); err != nil {

-		return err

-	}

-	if ret.Err != "" {

-		return errors.New(ret.Err)

-	}

-	return nil

-}

-

-func (d *graphDriverProxy) Remove(id string) error {

-	args := &graphDriverRequest{ID: id}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Remove", args, &ret); err != nil {

-		return err

-	}

-	if ret.Err != "" {

-		return errors.New(ret.Err)

-	}

-	return nil

-}

-

-func (d *graphDriverProxy) Get(id, mountLabel string) (string, error) {

-	args := &graphDriverRequest{

-		ID:         id,

-		MountLabel: mountLabel,

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Get", args, &ret); err != nil {

-		return "", err

-	}

-	var err error

-	if ret.Err != "" {

-		err = errors.New(ret.Err)

-	}

-	return d.p.ScopedPath(ret.Dir), err

-}

-

-func (d *graphDriverProxy) Put(id string) error {

-	args := &graphDriverRequest{ID: id}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Put", args, &ret); err != nil {

-		return err

-	}

-	if ret.Err != "" {

-		return errors.New(ret.Err)

-	}

-	return nil

-}

-

-func (d *graphDriverProxy) Exists(id string) bool {

-	args := &graphDriverRequest{ID: id}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Exists", args, &ret); err != nil {

-		return false

-	}

-	return ret.Exists

-}

-

-func (d *graphDriverProxy) Status() [][2]string {

-	args := &graphDriverRequest{}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Status", args, &ret); err != nil {

-		return nil

-	}

-	return ret.Status

-}

-

-func (d *graphDriverProxy) GetMetadata(id string) (map[string]string, error) {

-	args := &graphDriverRequest{

-		ID: id,

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.GetMetadata", args, &ret); err != nil {

-		return nil, err

-	}

-	if ret.Err != "" {

-		return nil, errors.New(ret.Err)

-	}

-	return ret.Metadata, nil

-}

-

-func (d *graphDriverProxy) Cleanup() error {

-	if !d.p.IsV1() {

-		if cp, ok := d.p.(plugingetter.CountedPlugin); ok {

-			// always release

-			defer cp.Release()

-		}

-	}

-

-	args := &graphDriverRequest{}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Cleanup", args, &ret); err != nil {

-		return nil

-	}

-	if ret.Err != "" {

-		return errors.New(ret.Err)

-	}

-	return nil

-}

-

-func (d *graphDriverProxy) Diff(id, parent string) (io.ReadCloser, error) {

-	args := &graphDriverRequest{

-		ID:     id,

-		Parent: parent,

-	}

-	body, err := d.client.Stream("GraphDriver.Diff", args)

-	if err != nil {

-		return nil, err

-	}

-	return body, nil

-}

-

-func (d *graphDriverProxy) Changes(id, parent string) ([]archive.Change, error) {

-	args := &graphDriverRequest{

-		ID:     id,

-		Parent: parent,

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.Changes", args, &ret); err != nil {

-		return nil, err

-	}

-	if ret.Err != "" {

-		return nil, errors.New(ret.Err)

-	}

-

-	return ret.Changes, nil

-}

-

-func (d *graphDriverProxy) ApplyDiff(id, parent string, diff io.Reader) (int64, error) {

-	var ret graphDriverResponse

-	if err := d.client.SendFile(fmt.Sprintf("GraphDriver.ApplyDiff?id=%s&parent=%s", id, parent), diff, &ret); err != nil {

-		return -1, err

-	}

-	if ret.Err != "" {

-		return -1, errors.New(ret.Err)

-	}

-	return ret.Size, nil

-}

-

-func (d *graphDriverProxy) DiffSize(id, parent string) (int64, error) {

-	args := &graphDriverRequest{

-		ID:     id,

-		Parent: parent,

-	}

-	var ret graphDriverResponse

-	if err := d.client.Call("GraphDriver.DiffSize", args, &ret); err != nil {

-		return -1, err

-	}

-	if ret.Err != "" {

-		return -1, errors.New(ret.Err)

-	}

-	return ret.Size, nil

-}

deleted file mode 100644

@@ -1,43 +0,0 @@

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

-

-import (

-	"encoding/json"

-	"testing"

-

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

-	"gotest.tools/v3/assert"

-)

-

-func TestGraphDriverInitRequestIsCompatible(t *testing.T) {

-	// Graph driver plugins may unmarshal into this version of the init

-	// request struct. Verify that the serialization of

-	// graphDriverInitRequest is fully backwards compatible.

-

-	type graphDriverInitRequestV1 struct {

-		Home    string

-		Opts    []string        `json:"Opts"`

-		UIDMaps []idtools.IDMap `json:"UIDMaps"`

-		GIDMaps []idtools.IDMap `json:"GIDMaps"`

-	}

-

-	args := graphDriverInitRequest{

-		Home: "homedir",

-		Opts: []string{"option1", "option2"},

-		IdentityMapping: idtools.IdentityMapping{

-			UIDMaps: []idtools.IDMap{{ContainerID: 123, HostID: 456, Size: 42}},

-			GIDMaps: []idtools.IDMap{{ContainerID: 789, HostID: 1011, Size: 16}},

-		},

-	}

-	v, err := json.Marshal(&args)

-	assert.NilError(t, err)

-

-	var got graphDriverInitRequestV1

-	assert.NilError(t, json.Unmarshal(v, &got))

-	want := graphDriverInitRequestV1{

-		Home:    args.Home,

-		Opts:    args.Opts,

-		UIDMaps: args.UIDMaps,

-		GIDMaps: args.GIDMaps,

-	}

-	assert.DeepEqual(t, got, want)

-}

@@ -92,8 +92,10 @@ func TestXattrUnsupportedByBackingFS(t *testing.T) {

 		t.Run(tt.name, func(t *testing.T) {

 			subdir := filepath.Join(rootdir, tt.name)

 			assert.NilError(t, os.Mkdir(subdir, 0o755))

-			d, err := graphdriver.GetDriver("vfs", nil,

-				graphdriver.Options{DriverOptions: tt.opts, Root: subdir})

+			d, err := graphdriver.GetDriver("vfs", graphdriver.Options{

+				DriverOptions: tt.opts,

+				Root:          subdir,

+			})

 			assert.NilError(t, err)

 			defer d.Cleanup()

@@ -52,7 +52,6 @@ func TestRemoveImageGarbageCollector(t *testing.T) {

 		GraphDriver:               d.StorageDriver(),

 		GraphDriverOptions:        nil,

 		IDMapping:                 idtools.IdentityMapping{},

-		PluginGetter:              nil,

 		ExperimentalEnabled:       false,

 	})

 	i := images.NewImageService(images.ImageServiceConfig{

deleted file mode 100644

@@ -1,469 +0,0 @@

-package graphdriver

-

-import (

-	"context"

-	"encoding/json"

-	"fmt"

-	"io"

-	"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/api/types/image"

-	"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/pkg/archive"

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

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

-	"github.com/docker/docker/testutil"

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

-	"gotest.tools/v3/assert"

-	is "gotest.tools/v3/assert/cmp"

-	"gotest.tools/v3/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, testEnv.UsingSnapshotter())

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

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

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

-	skip.If(t, testEnv.IsRootless, "rootless mode doesn't support external graph driver")

-

-	ctx := testutil.StartSpan(baseContext, 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(), daemon.WithEnvVars("DOCKERD_DEPRECATED_GRAPHDRIVER_PLUGINS=1"))

-	c := d.NewClientT(t)

-

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

-		name string

-		test func(context.Context, 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, func(t *testing.T) {

-			ctx := testutil.StartSpan(ctx, t)

-			tc.test(ctx, 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", plugins.VersionMimetype)

-		switch t := data.(type) {

-		case error:

-			fmt.Fprintf(w, "{\"Err\": %q}\n", 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 := os.MkdirTemp("", name)

-	assert.NilError(t, err)

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

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

-	driver := graphdriver.NewNaiveDiffDriver(vfsProto, idtools.IdentityMapping{})

-

-	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

-		}

-

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

-		if err != nil {

-			respond(w, err)

-			return

-		}

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

-	})

-

-	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, "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", 0o755)

-	assert.NilError(t, err)

-

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

-	err = os.WriteFile(specFile, b, 0o644)

-	assert.NilError(t, err)

-}

-

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

-	return func(ctx context.Context, c client.APIClient, d *daemon.Daemon) func(*testing.T) {

-		return func(t *testing.T) {

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

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

-

-			testGraphDriver(ctx, t, c, 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(ctx context.Context, c client.APIClient, d *daemon.Daemon) func(*testing.T) {

-	return func(t *testing.T) {

-		d.Start(t)

-		defer d.Stop(t)

-

-		r, err := c.ImagePull(ctx, "busybox:latest@sha256:95cf004f559831017cdf4628aaf1bb30133677be8702a8c5f2994629f637a209", image.PullOptions{})

-		assert.NilError(t, err)

-		_, err = io.Copy(io.Discard, r)

-		assert.NilError(t, err)

-

-		container.Run(ctx, t, c, container.WithImage("busybox:latest@sha256:95cf004f559831017cdf4628aaf1bb30133677be8702a8c5f2994629f637a209"))

-	}

-}

-

-func TestGraphdriverPluginV2(t *testing.T) {

-	skip.If(t, testEnv.UsingSnapshotter())

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