@@ -8,13 +8,14 @@ import (

 	cerrdefs "github.com/containerd/errdefs"

 	"github.com/containerd/log"

 	"github.com/distribution/reference"

+	"github.com/docker/docker/daemon/cluster/internal/runtime"

 	"github.com/docker/docker/daemon/pkg/plugin"

 	v2 "github.com/docker/docker/daemon/pkg/plugin/v2"

 	"github.com/docker/docker/daemon/server/backend"

 	"github.com/gogo/protobuf/proto"

 	"github.com/moby/moby/api/types"

 	"github.com/moby/moby/api/types/registry"

-	"github.com/moby/moby/api/types/swarm/runtime"

+	"github.com/moby/moby/api/types/swarm"

 	"github.com/moby/swarmkit/v2/api"

 	"github.com/pkg/errors"

 )

@@ -30,7 +31,7 @@ import (

 // the right way to pass registry credentials via secrets.

 type Controller struct {

 	backend Backend

-	spec    runtime.PluginSpec

+	spec    swarm.RuntimeSpec

 	logger  *log.Entry

 	pluginID  string

@@ -70,14 +71,15 @@ func NewController(backend Backend, t *api.Task) (*Controller, error) {

 	}, nil

 }

-func readSpec(t *api.Task) (runtime.PluginSpec, error) {

+func readSpec(t *api.Task) (swarm.RuntimeSpec, error) {

 	var cfg runtime.PluginSpec

 	generic := t.Spec.GetGeneric()

 	if err := proto.Unmarshal(generic.Payload.Value, &cfg); err != nil {

-		return cfg, errors.Wrap(err, "error reading plugin spec")

+		return swarm.RuntimeSpec{}, errors.Wrap(err, "error reading plugin spec")

 	}

-	return cfg, nil

+

+	return runtime.ToAPI(cfg), nil

 }

 // Update is the update phase from swarmkit

@@ -248,7 +250,7 @@ func (p *Controller) Close() error {

 	return nil

 }

-func convertPrivileges(ls []*runtime.PluginPrivilege) types.PluginPrivileges {

+func convertPrivileges(ls []*swarm.RuntimePrivilege) types.PluginPrivileges {

 	var out types.PluginPrivileges

 	for _, p := range ls {

 		pp := types.PluginPrivilege{

@@ -16,7 +16,7 @@ import (

 	"github.com/docker/docker/daemon/server/backend"

 	"github.com/moby/moby/api/types"

 	"github.com/moby/moby/api/types/registry"

-	"github.com/moby/moby/api/types/swarm/runtime"

+	"github.com/moby/moby/api/types/swarm"

 	"github.com/moby/pubsub"

 	"github.com/sirupsen/logrus"

 )

@@ -325,7 +325,7 @@ func newTestController(b Backend, disabled bool) *Controller {

 	return &Controller{

 		logger:  &log.Entry{Logger: &logrus.Logger{Out: io.Discard}},

 		backend: b,

-		spec: runtime.PluginSpec{

+		spec: swarm.RuntimeSpec{

 			Name:     pluginTestName,

 			Remote:   pluginTestRemote,

 			Disabled: disabled,

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

 	"fmt"

 	"strings"

+	"github.com/docker/docker/daemon/cluster/internal/runtime"

 	"github.com/docker/docker/pkg/namesgenerator"

 	"github.com/gogo/protobuf/proto"

 	gogotypes "github.com/gogo/protobuf/types"

 	types "github.com/moby/moby/api/types/swarm"

-	"github.com/moby/moby/api/types/swarm/runtime"

 	swarmapi "github.com/moby/swarmkit/v2/api"

 	"github.com/moby/swarmkit/v2/api/genericresource"

 	"github.com/pkg/errors"

@@ -210,7 +210,8 @@ func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {

 			s.Mode.Global = &types.GlobalService{} // must always be global

-			pluginSpec, err := proto.Marshal(s.TaskTemplate.PluginSpec)

+			ps := runtime.FromAPI(*s.TaskTemplate.PluginSpec)

+			pluginSpec, err := proto.Marshal(&ps)

 			if err != nil {

 				return swarmapi.ServiceSpec{}, err

 			}

@@ -699,7 +700,8 @@ func taskSpecFromGRPC(taskSpec swarmapi.TaskSpec) (types.TaskSpec, error) {

 				if err := proto.Unmarshal(g.Payload.Value, &p); err != nil {

 					return t, errors.Wrap(err, "error unmarshalling plugin spec")

 				}

-				t.PluginSpec = &p

+				ap := runtime.ToAPI(p)

+				t.PluginSpec = &ap

 			}

 		}

 	case *swarmapi.TaskSpec_Attachment:

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

 	containertypes "github.com/moby/moby/api/types/container"

 	"github.com/moby/moby/api/types/mount"

 	swarmtypes "github.com/moby/moby/api/types/swarm"

-	"github.com/moby/moby/api/types/swarm/runtime"

 	swarmapi "github.com/moby/swarmkit/v2/api"

 	"gotest.tools/v3/assert"

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

@@ -89,7 +88,7 @@ func TestServiceConvertToGRPCGenericRuntimePlugin(t *testing.T) {

 	s := swarmtypes.ServiceSpec{

 		TaskTemplate: swarmtypes.TaskSpec{

 			Runtime:    swarmtypes.RuntimePlugin,

-			PluginSpec: &runtime.PluginSpec{},

+			PluginSpec: &swarmtypes.RuntimeSpec{},

 		},

 		Mode: swarmtypes.ServiceMode{

 			Global: &swarmtypes.GlobalService{},

@@ -425,7 +424,7 @@ func TestServiceConvertToGRPCMismatchedRuntime(t *testing.T) {

 	} {

 		for j, spec := range []swarmtypes.TaskSpec{

 			{ContainerSpec: &swarmtypes.ContainerSpec{}},

-			{PluginSpec: &runtime.PluginSpec{}},

+			{PluginSpec: &swarmtypes.RuntimeSpec{}},

 		} {

 			// skip the cases, where the indices match, which would not error

 			if i == j {

new file mode 100644

@@ -0,0 +1,49 @@

+package runtime

+

+import "github.com/moby/moby/api/types/swarm"

+

+func privilegesFromAPI(privs []*swarm.RuntimePrivilege) []*PluginPrivilege {

+	var out []*PluginPrivilege

+	for _, p := range privs {

+		out = append(out, &PluginPrivilege{

+			Name:        p.Name,

+			Description: p.Description,

+			Value:       p.Value,

+		})

+	}

+	return out

+}

+

+// FromAPI converts an API RuntimeSpec to a PluginSpec,

+// which can be proto encoded.

+func FromAPI(spec swarm.RuntimeSpec) PluginSpec {

+	return PluginSpec{

+		Name:       spec.Name,

+		Remote:     spec.Remote,

+		Privileges: privilegesFromAPI(spec.Privileges),

+		Disabled:   spec.Disabled,

+		Env:        spec.Env,

+	}

+}

+

+func privilegesToAPI(privs []*PluginPrivilege) []*swarm.RuntimePrivilege {

+	var out []*swarm.RuntimePrivilege

+	for _, p := range privs {

+		out = append(out, &swarm.RuntimePrivilege{

+			Name:        p.Name,

+			Description: p.Description,

+			Value:       p.Value,

+		})

+	}

+	return out

+}

+

+func ToAPI(spec PluginSpec) swarm.RuntimeSpec {

+	return swarm.RuntimeSpec{

+		Name:       spec.Name,

+		Remote:     spec.Remote,

+		Privileges: privilegesToAPI(spec.Privileges),

+		Disabled:   spec.Disabled,

+		Env:        spec.Env,

+	}

+}

new file mode 100644

@@ -0,0 +1,3 @@

+//go:generate protoc --gogofaster_out=import_path=runtime:. plugin.proto

+

+package runtime

new file mode 100644

@@ -0,0 +1,808 @@

+// Code generated by protoc-gen-gogo. DO NOT EDIT.

+// source: plugin.proto

+

+package runtime

+

+import (

+	fmt "fmt"

+	proto "github.com/gogo/protobuf/proto"

+	io "io"

+	math "math"

+	math_bits "math/bits"

+)

+

+// Reference imports to suppress errors if they are not otherwise used.

+var _ = proto.Marshal

+var _ = fmt.Errorf

+var _ = math.Inf

+

+// This is a compile-time assertion to ensure that this generated file

+// is compatible with the proto package it is being compiled against.

+// A compilation error at this line likely means your copy of the

+// proto package needs to be updated.

+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

+

+// PluginSpec defines the base payload which clients can specify for creating

+// a service with the plugin runtime.

+type PluginSpec struct {

+	Name       string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`

+	Remote     string             `protobuf:"bytes,2,opt,name=remote,proto3" json:"remote,omitempty"`

+	Privileges []*PluginPrivilege `protobuf:"bytes,3,rep,name=privileges,proto3" json:"privileges,omitempty"`

+	Disabled   bool               `protobuf:"varint,4,opt,name=disabled,proto3" json:"disabled,omitempty"`

+	Env        []string           `protobuf:"bytes,5,rep,name=env,proto3" json:"env,omitempty"`

+}

+

+func (m *PluginSpec) Reset()         { *m = PluginSpec{} }

+func (m *PluginSpec) String() string { return proto.CompactTextString(m) }

+func (*PluginSpec) ProtoMessage()    {}

+func (*PluginSpec) Descriptor() ([]byte, []int) {

+	return fileDescriptor_22a625af4bc1cc87, []int{0}

+}

+func (m *PluginSpec) XXX_Unmarshal(b []byte) error {

+	return m.Unmarshal(b)

+}

+func (m *PluginSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

+	if deterministic {

+		return xxx_messageInfo_PluginSpec.Marshal(b, m, deterministic)

+	} else {

+		b = b[:cap(b)]

+		n, err := m.MarshalToSizedBuffer(b)

+		if err != nil {

+			return nil, err

+		}

+		return b[:n], nil

+	}

+}

+func (m *PluginSpec) XXX_Merge(src proto.Message) {

+	xxx_messageInfo_PluginSpec.Merge(m, src)

+}

+func (m *PluginSpec) XXX_Size() int {

+	return m.Size()

+}

+func (m *PluginSpec) XXX_DiscardUnknown() {

+	xxx_messageInfo_PluginSpec.DiscardUnknown(m)

+}

+

+var xxx_messageInfo_PluginSpec proto.InternalMessageInfo

+

+func (m *PluginSpec) GetName() string {

+	if m != nil {

+		return m.Name

+	}

+	return ""

+}

+

+func (m *PluginSpec) GetRemote() string {

+	if m != nil {

+		return m.Remote

+	}

+	return ""

+}

+

+func (m *PluginSpec) GetPrivileges() []*PluginPrivilege {

+	if m != nil {

+		return m.Privileges

+	}

+	return nil

+}

+

+func (m *PluginSpec) GetDisabled() bool {

+	if m != nil {

+		return m.Disabled

+	}

+	return false

+}

+

+func (m *PluginSpec) GetEnv() []string {

+	if m != nil {

+		return m.Env

+	}

+	return nil

+}

+

+// PluginPrivilege describes a permission the user has to accept

+// upon installing a plugin.

+type PluginPrivilege struct {

+	Name        string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`

+	Description string   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`

+	Value       []string `protobuf:"bytes,3,rep,name=value,proto3" json:"value,omitempty"`

+}

+

+func (m *PluginPrivilege) Reset()         { *m = PluginPrivilege{} }

+func (m *PluginPrivilege) String() string { return proto.CompactTextString(m) }

+func (*PluginPrivilege) ProtoMessage()    {}

+func (*PluginPrivilege) Descriptor() ([]byte, []int) {

+	return fileDescriptor_22a625af4bc1cc87, []int{1}

+}

+func (m *PluginPrivilege) XXX_Unmarshal(b []byte) error {

+	return m.Unmarshal(b)

+}

+func (m *PluginPrivilege) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

+	if deterministic {

+		return xxx_messageInfo_PluginPrivilege.Marshal(b, m, deterministic)

+	} else {

+		b = b[:cap(b)]

+		n, err := m.MarshalToSizedBuffer(b)

+		if err != nil {

+			return nil, err

+		}

+		return b[:n], nil

+	}

+}

+func (m *PluginPrivilege) XXX_Merge(src proto.Message) {

+	xxx_messageInfo_PluginPrivilege.Merge(m, src)

+}

+func (m *PluginPrivilege) XXX_Size() int {

+	return m.Size()

+}

+func (m *PluginPrivilege) XXX_DiscardUnknown() {

+	xxx_messageInfo_PluginPrivilege.DiscardUnknown(m)

+}

+

+var xxx_messageInfo_PluginPrivilege proto.InternalMessageInfo

+

+func (m *PluginPrivilege) GetName() string {

+	if m != nil {

+		return m.Name

+	}

+	return ""

+}

+

+func (m *PluginPrivilege) GetDescription() string {

+	if m != nil {

+		return m.Description

+	}

+	return ""

+}

+

+func (m *PluginPrivilege) GetValue() []string {

+	if m != nil {

+		return m.Value

+	}

+	return nil

+}

+

+func init() {

+	proto.RegisterType((*PluginSpec)(nil), "PluginSpec")

+	proto.RegisterType((*PluginPrivilege)(nil), "PluginPrivilege")

+}

+

+func init() { proto.RegisterFile("plugin.proto", fileDescriptor_22a625af4bc1cc87) }

+

+var fileDescriptor_22a625af4bc1cc87 = []byte{

+	// 225 bytes of a gzipped FileDescriptorProto

+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0xc8, 0x29, 0x4d,

+	0xcf, 0xcc, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x9a, 0xc1, 0xc8, 0xc5, 0x15, 0x00, 0x16,

+	0x08, 0x2e, 0x48, 0x4d, 0x16, 0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, 0x4d, 0x95, 0x60, 0x54, 0x60,

+	0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x85, 0xc4, 0xb8, 0xd8, 0x8a, 0x52, 0x73, 0xf3, 0x4b, 0x52, 0x25,

+	0x98, 0xc0, 0xa2, 0x50, 0x9e, 0x90, 0x01, 0x17, 0x57, 0x41, 0x51, 0x66, 0x59, 0x66, 0x4e, 0x6a,

+	0x7a, 0x6a, 0xb1, 0x04, 0xb3, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x80, 0x1e, 0xc4, 0xb0, 0x00, 0x98,

+	0x44, 0x10, 0x92, 0x1a, 0x21, 0x29, 0x2e, 0x8e, 0x94, 0xcc, 0xe2, 0xc4, 0xa4, 0x9c, 0xd4, 0x14,

+	0x09, 0x16, 0x05, 0x46, 0x0d, 0x8e, 0x20, 0x38, 0x5f, 0x48, 0x80, 0x8b, 0x39, 0x35, 0xaf, 0x4c,

+	0x82, 0x55, 0x81, 0x59, 0x83, 0x33, 0x08, 0xc4, 0x54, 0x8a, 0xe5, 0xe2, 0x47, 0x33, 0x0c, 0xab,

+	0xf3, 0x14, 0xb8, 0xb8, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, 0x0b, 0x4a, 0x32, 0xf3, 0xf3, 0xa0,

+	0x6e, 0x44, 0x16, 0x12, 0x12, 0xe1, 0x62, 0x2d, 0x4b, 0xcc, 0x29, 0x4d, 0x05, 0xbb, 0x91, 0x33,

+	0x08, 0xc2, 0x71, 0x92, 0x38, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4,

+	0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x24, 0x36,

+	0x70, 0xd0, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x37, 0xea, 0xe2, 0xca, 0x2a, 0x01, 0x00,

+	0x00,

+}

+

+func (m *PluginSpec) Marshal() (dAtA []byte, err error) {

+	size := m.Size()

+	dAtA = make([]byte, size)

+	n, err := m.MarshalToSizedBuffer(dAtA[:size])

+	if err != nil {

+		return nil, err

+	}

+	return dAtA[:n], nil

+}

+

+func (m *PluginSpec) MarshalTo(dAtA []byte) (int, error) {

+	size := m.Size()

+	return m.MarshalToSizedBuffer(dAtA[:size])

+}

+

+func (m *PluginSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {

+	i := len(dAtA)

+	_ = i

+	var l int

+	_ = l

+	if len(m.Env) > 0 {

+		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {

+			i -= len(m.Env[iNdEx])

+			copy(dAtA[i:], m.Env[iNdEx])

+			i = encodeVarintPlugin(dAtA, i, uint64(len(m.Env[iNdEx])))

+			i--

+			dAtA[i] = 0x2a

+		}

+	}

+	if m.Disabled {

+		i--

+		if m.Disabled {

+			dAtA[i] = 1

+		} else {

+			dAtA[i] = 0

+		}

+		i--

+		dAtA[i] = 0x20

+	}

+	if len(m.Privileges) > 0 {

+		for iNdEx := len(m.Privileges) - 1; iNdEx >= 0; iNdEx-- {

+			{

+				size, err := m.Privileges[iNdEx].MarshalToSizedBuffer(dAtA[:i])

+				if err != nil {

+					return 0, err

+				}

+				i -= size

+				i = encodeVarintPlugin(dAtA, i, uint64(size))

+			}

+			i--

+			dAtA[i] = 0x1a

+		}

+	}

+	if len(m.Remote) > 0 {

+		i -= len(m.Remote)

+		copy(dAtA[i:], m.Remote)

+		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Remote)))

+		i--

+		dAtA[i] = 0x12

+	}

+	if len(m.Name) > 0 {

+		i -= len(m.Name)

+		copy(dAtA[i:], m.Name)

+		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Name)))

+		i--

+		dAtA[i] = 0xa

+	}

+	return len(dAtA) - i, nil

+}

+

+func (m *PluginPrivilege) Marshal() (dAtA []byte, err error) {

+	size := m.Size()

+	dAtA = make([]byte, size)

+	n, err := m.MarshalToSizedBuffer(dAtA[:size])

+	if err != nil {

+		return nil, err

+	}

+	return dAtA[:n], nil

+}

+

+func (m *PluginPrivilege) MarshalTo(dAtA []byte) (int, error) {

+	size := m.Size()

+	return m.MarshalToSizedBuffer(dAtA[:size])

+}

+

+func (m *PluginPrivilege) MarshalToSizedBuffer(dAtA []byte) (int, error) {

+	i := len(dAtA)

+	_ = i

+	var l int

+	_ = l

+	if len(m.Value) > 0 {

+		for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- {

+			i -= len(m.Value[iNdEx])

+			copy(dAtA[i:], m.Value[iNdEx])

+			i = encodeVarintPlugin(dAtA, i, uint64(len(m.Value[iNdEx])))

+			i--

+			dAtA[i] = 0x1a

+		}

+	}

+	if len(m.Description) > 0 {

+		i -= len(m.Description)

+		copy(dAtA[i:], m.Description)

+		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Description)))

+		i--

+		dAtA[i] = 0x12

+	}

+	if len(m.Name) > 0 {

+		i -= len(m.Name)

+		copy(dAtA[i:], m.Name)

+		i = encodeVarintPlugin(dAtA, i, uint64(len(m.Name)))

+		i--

+		dAtA[i] = 0xa

+	}

+	return len(dAtA) - i, nil

+}

+

+func encodeVarintPlugin(dAtA []byte, offset int, v uint64) int {

+	offset -= sovPlugin(v)

+	base := offset

+	for v >= 1<<7 {

+		dAtA[offset] = uint8(v&0x7f | 0x80)

+		v >>= 7

+		offset++

+	}

+	dAtA[offset] = uint8(v)

+	return base

+}

+func (m *PluginSpec) Size() (n int) {

+	if m == nil {

+		return 0

+	}

+	var l int

+	_ = l

+	l = len(m.Name)

+	if l > 0 {

+		n += 1 + l + sovPlugin(uint64(l))

+	}

+	l = len(m.Remote)

+	if l > 0 {

+		n += 1 + l + sovPlugin(uint64(l))

+	}

+	if len(m.Privileges) > 0 {

+		for _, e := range m.Privileges {

+			l = e.Size()

+			n += 1 + l + sovPlugin(uint64(l))

+		}

+	}

+	if m.Disabled {

+		n += 2

+	}

+	if len(m.Env) > 0 {

+		for _, s := range m.Env {

+			l = len(s)

+			n += 1 + l + sovPlugin(uint64(l))

+		}

+	}

+	return n

+}

+

+func (m *PluginPrivilege) Size() (n int) {

+	if m == nil {

+		return 0

+	}

+	var l int

+	_ = l

+	l = len(m.Name)

+	if l > 0 {

+		n += 1 + l + sovPlugin(uint64(l))

+	}

+	l = len(m.Description)

+	if l > 0 {

+		n += 1 + l + sovPlugin(uint64(l))

+	}

+	if len(m.Value) > 0 {

+		for _, s := range m.Value {

+			l = len(s)

+			n += 1 + l + sovPlugin(uint64(l))

+		}

+	}

+	return n

+}

+

+func sovPlugin(x uint64) (n int) {

+	return (math_bits.Len64(x|1) + 6) / 7

+}

+func sozPlugin(x uint64) (n int) {

+	return sovPlugin(uint64((x << 1) ^ uint64((int64(x) >> 63))))

+}

+func (m *PluginSpec) Unmarshal(dAtA []byte) error {

+	l := len(dAtA)

+	iNdEx := 0

+	for iNdEx < l {

+		preIndex := iNdEx

+		var wire uint64

+		for shift := uint(0); ; shift += 7 {

+			if shift >= 64 {

+				return ErrIntOverflowPlugin

+			}

+			if iNdEx >= l {

+				return io.ErrUnexpectedEOF

+			}

+			b := dAtA[iNdEx]

+			iNdEx++

+			wire |= uint64(b&0x7F) << shift

+			if b < 0x80 {

+				break

+			}

+		}

+		fieldNum := int32(wire >> 3)

+		wireType := int(wire & 0x7)

+		if wireType == 4 {

+			return fmt.Errorf("proto: PluginSpec: wiretype end group for non-group")

+		}

+		if fieldNum <= 0 {

+			return fmt.Errorf("proto: PluginSpec: illegal tag %d (wire type %d)", fieldNum, wire)

+		}

+		switch fieldNum {

+		case 1:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			intStringLen := int(stringLen)

+			if intStringLen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + intStringLen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Name = string(dAtA[iNdEx:postIndex])

+			iNdEx = postIndex

+		case 2:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			intStringLen := int(stringLen)

+			if intStringLen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + intStringLen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Remote = string(dAtA[iNdEx:postIndex])

+			iNdEx = postIndex

+		case 3:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Privileges", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				msglen |= int(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + msglen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Privileges = append(m.Privileges, &PluginPrivilege{})

+			if err := m.Privileges[len(m.Privileges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

+		case 4:

+			if wireType != 0 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Disabled", wireType)

+			}

+			var v int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				v |= int(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			m.Disabled = bool(v != 0)

+		case 5:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Env", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			intStringLen := int(stringLen)

+			if intStringLen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + intStringLen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Env = append(m.Env, string(dAtA[iNdEx:postIndex]))

+			iNdEx = postIndex

+		default:

+			iNdEx = preIndex

+			skippy, err := skipPlugin(dAtA[iNdEx:])

+			if err != nil {

+				return err

+			}

+			if (skippy < 0) || (iNdEx+skippy) < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if (iNdEx + skippy) > l {

+				return io.ErrUnexpectedEOF

+			}

+			iNdEx += skippy

+		}

+	}

+

+	if iNdEx > l {

+		return io.ErrUnexpectedEOF

+	}

+	return nil

+}

+func (m *PluginPrivilege) Unmarshal(dAtA []byte) error {

+	l := len(dAtA)

+	iNdEx := 0

+	for iNdEx < l {

+		preIndex := iNdEx

+		var wire uint64

+		for shift := uint(0); ; shift += 7 {

+			if shift >= 64 {

+				return ErrIntOverflowPlugin

+			}

+			if iNdEx >= l {

+				return io.ErrUnexpectedEOF

+			}

+			b := dAtA[iNdEx]

+			iNdEx++

+			wire |= uint64(b&0x7F) << shift

+			if b < 0x80 {

+				break

+			}

+		}

+		fieldNum := int32(wire >> 3)

+		wireType := int(wire & 0x7)

+		if wireType == 4 {

+			return fmt.Errorf("proto: PluginPrivilege: wiretype end group for non-group")

+		}

+		if fieldNum <= 0 {

+			return fmt.Errorf("proto: PluginPrivilege: illegal tag %d (wire type %d)", fieldNum, wire)

+		}

+		switch fieldNum {

+		case 1:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			intStringLen := int(stringLen)

+			if intStringLen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + intStringLen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Name = string(dAtA[iNdEx:postIndex])

+			iNdEx = postIndex

+		case 2:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			intStringLen := int(stringLen)

+			if intStringLen < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			postIndex := iNdEx + intStringLen

+			if postIndex < 0 {

+				return ErrInvalidLengthPlugin

+			}

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Description = string(dAtA[iNdEx:postIndex])

+			iNdEx = postIndex

+		case 3:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)

+			}

+			var stringLen uint64

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowPlugin

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				stringLen |= uint64(b&0x7F) << shift