Remove Reference of itemsnapshotter (#5997)

It will be removed as we choose to use BIAv2 for progress monitoring.

Signed-off-by: Daniel Jiang <jiangd@vmware.com>

pkg/plugin/framework/action_resolver.go

@@ -27,7 +27,6 @@ import (
 	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
 	biav1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/backupitemaction/v1"
 	biav2 "github.com/vmware-tanzu/velero/pkg/plugin/velero/backupitemaction/v2"
-	isv1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/item_snapshotter/v1"
 	riav1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/restoreitemaction/v1"
 	riav2 "github.com/vmware-tanzu/velero/pkg/plugin/velero/restoreitemaction/v2"
 	"github.com/vmware-tanzu/velero/pkg/util/collections"
@@ -141,12 +140,6 @@ func NewDeleteItemActionResolver(actions []velero.DeleteItemAction) DeleteItemAc
 	}
 }
 
-func NewItemSnapshotterResolver(actions []isv1.ItemSnapshotter) ItemSnapshotterResolver {
-	return ItemSnapshotterResolver{
-		actions: actions,
-	}
-}
-
 type ActionResolver interface {
 	ResolveAction(helper discovery.Helper, action velero.Applicable, log logrus.FieldLogger) (ResolvedAction, error)
 }
@@ -287,32 +280,3 @@ func (recv DeleteItemActionResolver) ResolveActions(helper discovery.Helper, log
 	}
 	return resolved, nil
 }
-
-type ItemSnapshotterResolvedAction struct {
-	isv1.ItemSnapshotter
-	resolvedAction
-}
-
-type ItemSnapshotterResolver struct {
-	actions []isv1.ItemSnapshotter
-}
-
-func (recv ItemSnapshotterResolver) ResolveActions(helper discovery.Helper, log logrus.FieldLogger) ([]ItemSnapshotterResolvedAction, error) {
-	var resolved []ItemSnapshotterResolvedAction
-	for _, action := range recv.actions {
-		resources, namespaces, selector, err := resolveAction(helper, action)
-		if err != nil {
-			return nil, err
-		}
-		res := ItemSnapshotterResolvedAction{
-			ItemSnapshotter: action,
-			resolvedAction: resolvedAction{
-				ResourceIncludesExcludes:  resources,
-				NamespaceIncludesExcludes: namespaces,
-				Selector:                  selector,
-			},
-		}
-		resolved = append(resolved, res)
-	}
-	return resolved, nil
-}

pkg/plugin/framework/common/plugin_kinds.go

@@ -47,9 +47,6 @@ const (
 	// PluginKindDeleteItemAction represents a delete item action plugin.
 	PluginKindDeleteItemAction PluginKind = "DeleteItemAction"
 
-	// PluginKindItemSnapshotter represents an item snapshotter plugin
-	PluginKindItemSnapshotter PluginKind = "ItemSnapshotter"
-
 	// PluginKindPluginLister represents a plugin lister plugin.
 	PluginKindPluginLister PluginKind = "PluginLister"
 )
@@ -73,6 +70,5 @@ func AllPluginKinds() map[string]PluginKind {
 	allPluginKinds[PluginKindRestoreItemAction.String()] = PluginKindRestoreItemAction
 	allPluginKinds[PluginKindRestoreItemActionV2.String()] = PluginKindRestoreItemActionV2
 	allPluginKinds[PluginKindDeleteItemAction.String()] = PluginKindDeleteItemAction
-	allPluginKinds[PluginKindItemSnapshotter.String()] = PluginKindItemSnapshotter
 	return allPluginKinds
 }

pkg/plugin/framework/item_snapshotter.go

@@ -1,45 +0,0 @@
-/*
-Copyright the Velero contributors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package framework
-
-import (
-	plugin "github.com/hashicorp/go-plugin"
-	"golang.org/x/net/context"
-	"google.golang.org/grpc"
-
-	"github.com/vmware-tanzu/velero/pkg/plugin/framework/common"
-	proto "github.com/vmware-tanzu/velero/pkg/plugin/generated"
-)
-
-// ItemSnapshotterPlugin is an implementation of go-plugin's Plugin
-// interface with support for gRPC for the ItemSnapshotter
-// interface.
-type ItemSnapshotterPlugin struct {
-	plugin.NetRPCUnsupportedPlugin
-	*common.PluginBase
-}
-
-// GRPCClient returns a clientDispenser for ItemSnapshotter gRPC clients.
-func (p *ItemSnapshotterPlugin) GRPCClient(_ context.Context, _ *plugin.GRPCBroker, clientConn *grpc.ClientConn) (interface{}, error) {
-	return common.NewClientDispenser(p.ClientLogger, clientConn, newItemSnapshotterGRPCClient), nil
-}
-
-// GRPCServer registers an ItemSnapshotter gRPC server.
-func (p *ItemSnapshotterPlugin) GRPCServer(_ *plugin.GRPCBroker, server *grpc.Server) error {
-	proto.RegisterItemSnapshotterServer(server, &ItemSnapshotterGRPCServer{mux: p.ServerMux})
-	return nil
-}

pkg/plugin/framework/item_snapshotter_client.go

@@ -1,240 +0,0 @@
-/*
-Copyright the Velero contributors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package framework
-
-import (
-	"context"
-	"encoding/json"
-	"time"
-
-	"github.com/pkg/errors"
-	"google.golang.org/grpc"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-
-	"github.com/vmware-tanzu/velero/pkg/plugin/framework/common"
-	proto "github.com/vmware-tanzu/velero/pkg/plugin/generated"
-	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
-	isv1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/item_snapshotter/v1"
-)
-
-// NewItemSnapshotterPlugin constructs a ItemSnapshotterPlugin.
-func NewItemSnapshotterPlugin(options ...common.PluginOption) *ItemSnapshotterPlugin {
-	return &ItemSnapshotterPlugin{
-		PluginBase: common.NewPluginBase(options...),
-	}
-}
-
-func newItemSnapshotterGRPCClient(base *common.ClientBase, clientConn *grpc.ClientConn) interface{} {
-	return &ItemSnapshotterGRPCClient{
-		ClientBase: base,
-		grpcClient: proto.NewItemSnapshotterClient(clientConn),
-	}
-}
-
-// ItemSnapshotterGRPCClient implements the ItemSnapshotter interface and uses a
-// gRPC client to make calls to the plugin server.
-type ItemSnapshotterGRPCClient struct {
-	*common.ClientBase
-	grpcClient proto.ItemSnapshotterClient
-}
-
-func (recv ItemSnapshotterGRPCClient) Init(config map[string]string) error {
-	req := &proto.ItemSnapshotterInitRequest{
-		Plugin: recv.Plugin,
-		Config: config,
-	}
-
-	_, err := recv.grpcClient.Init(context.Background(), req)
-	return err
-}
-
-func (recv ItemSnapshotterGRPCClient) AppliesTo() (velero.ResourceSelector, error) {
-	req := &proto.ItemSnapshotterAppliesToRequest{
-		Plugin: recv.Plugin,
-	}
-
-	res, err := recv.grpcClient.AppliesTo(context.Background(), req)
-	if err != nil {
-		return velero.ResourceSelector{}, common.FromGRPCError(err)
-	}
-
-	if res.ResourceSelector == nil {
-		return velero.ResourceSelector{}, nil
-	}
-
-	return velero.ResourceSelector{
-		IncludedNamespaces: res.ResourceSelector.IncludedNamespaces,
-		ExcludedNamespaces: res.ResourceSelector.ExcludedNamespaces,
-		IncludedResources:  res.ResourceSelector.IncludedResources,
-		ExcludedResources:  res.ResourceSelector.ExcludedResources,
-		LabelSelector:      res.ResourceSelector.Selector,
-	}, nil
-}
-
-func (recv ItemSnapshotterGRPCClient) AlsoHandles(input *isv1.AlsoHandlesInput) ([]velero.ResourceIdentifier, error) {
-	itemJSON, err := json.Marshal(input.Item.UnstructuredContent())
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	backupJSON, err := json.Marshal(input.Backup)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	req := &proto.AlsoHandlesRequest{
-		Plugin: recv.Plugin,
-		Item:   itemJSON,
-		Backup: backupJSON,
-	}
-	res, err := recv.grpcClient.AlsoHandles(context.Background(), req)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	handledItems := unpackResourceIdentifiers(res.HandledItems)
-
-	return handledItems, nil
-}
-
-func (recv ItemSnapshotterGRPCClient) SnapshotItem(ctx context.Context, input *isv1.SnapshotItemInput) (*isv1.SnapshotItemOutput, error) {
-	itemJSON, err := json.Marshal(input.Item.UnstructuredContent())
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	backupJSON, err := json.Marshal(input.Backup)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	req := &proto.SnapshotItemRequest{
-		Plugin: recv.Plugin,
-		Item:   itemJSON,
-		Backup: backupJSON,
-	}
-	res, err := recv.grpcClient.SnapshotItem(ctx, req)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	var updatedItem unstructured.Unstructured
-	if err := json.Unmarshal(res.Item, &updatedItem); err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	additionalItems := unpackResourceIdentifiers(res.AdditionalItems)
-	handledItems := unpackResourceIdentifiers(res.HandledItems)
-
-	sio := isv1.SnapshotItemOutput{
-		UpdatedItem:      &updatedItem,
-		SnapshotID:       res.SnapshotID,
-		SnapshotMetadata: res.SnapshotMetadata,
-		AdditionalItems:  additionalItems,
-		HandledItems:     handledItems,
-	}
-	return &sio, nil
-}
-
-func (recv ItemSnapshotterGRPCClient) Progress(input *isv1.ProgressInput) (*isv1.ProgressOutput, error) {
-	backupJSON, err := json.Marshal(input.Backup)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	req := &proto.ProgressRequest{
-		Plugin:     recv.Plugin,
-		ItemID:     resourceIdentifierToProto(input.ItemID),
-		SnapshotID: input.SnapshotID,
-		Backup:     backupJSON,
-	}
-
-	res, err := recv.grpcClient.Progress(context.Background(), req)
-
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	// Validate phase
-
-	phase, err := isv1.SnapshotPhaseFromString(res.Phase)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	up := isv1.ProgressOutput{
-		Phase:           phase,
-		Err:             res.Err,
-		ItemsCompleted:  res.ItemsCompleted,
-		ItemsToComplete: res.ItemsToComplete,
-		Started:         time.Unix(res.Started, res.StartedNano),
-		Updated:         time.Unix(res.Updated, res.UpdatedNano),
-	}
-	return &up, nil
-}
-
-func (recv ItemSnapshotterGRPCClient) DeleteSnapshot(ctx context.Context, input *isv1.DeleteSnapshotInput) error {
-	req := &proto.DeleteItemSnapshotRequest{
-		Plugin:     recv.Plugin,
-		Params:     input.Params,
-		SnapshotID: input.SnapshotID,
-	}
-	_, err := recv.grpcClient.DeleteSnapshot(ctx, req) // Returns Empty as first arg so just ignore
-
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	return nil
-}
-
-func (recv ItemSnapshotterGRPCClient) CreateItemFromSnapshot(ctx context.Context, input *isv1.CreateItemInput) (*isv1.CreateItemOutput, error) {
-	itemJSON, err := json.Marshal(input.SnapshottedItem.UnstructuredContent())
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	itemFromBackupJSON, err := json.Marshal(input.ItemFromBackup.UnstructuredContent())
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	restoreJSON, err := json.Marshal(input.Restore)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	req := &proto.CreateItemFromSnapshotRequest{
-		Plugin:           recv.Plugin,
-		Item:             itemJSON,
-		SnapshotID:       input.SnapshotID,
-		ItemFromBackup:   itemFromBackupJSON,
-		SnapshotMetadata: input.SnapshotMetadata,
-		Params:           input.Params,
-		Restore:          restoreJSON,
-	}
-
-	res, err := recv.grpcClient.CreateItemFromSnapshot(ctx, req)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	var updatedItem unstructured.Unstructured
-	if err := json.Unmarshal(res.Item, &updatedItem); err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	additionalItems := unpackResourceIdentifiers(res.AdditionalItems)
-
-	cio := isv1.CreateItemOutput{
-		UpdatedItem:     &updatedItem,
-		AdditionalItems: additionalItems,
-		SkipRestore:     res.SkipRestore,
-	}
-	return &cio, nil
-}

pkg/plugin/framework/item_snapshotter_server.go

@@ -1,312 +0,0 @@
-/*
-Copyright the Velero contributors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-package framework
-
-import (
-	"context"
-	"encoding/json"
-
-	isv1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/item_snapshotter/v1"
-
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-
-	api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
-
-	"github.com/pkg/errors"
-
-	"github.com/vmware-tanzu/velero/pkg/plugin/framework/common"
-	proto "github.com/vmware-tanzu/velero/pkg/plugin/generated"
-)
-
-// ItemSnapshotterGRPCServer implements the proto-generated ItemSnapshotterServer interface, and accepts
-// gRPC calls and forwards them to an implementation of the pluggable interface.
-type ItemSnapshotterGRPCServer struct {
-	mux *common.ServerMux
-}
-
-func (recv *ItemSnapshotterGRPCServer) getImpl(name string) (isv1.ItemSnapshotter, error) {
-	impl, err := recv.mux.GetHandler(name)
-	if err != nil {
-		return nil, err
-	}
-
-	itemAction, ok := impl.(isv1.ItemSnapshotter)
-	if !ok {
-		return nil, errors.Errorf("%T is not an item snapshotter", impl)
-	}
-
-	return itemAction, nil
-}
-
-func (recv *ItemSnapshotterGRPCServer) Init(c context.Context, req *proto.ItemSnapshotterInitRequest) (response *proto.Empty, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	err = impl.Init(req.Config)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	return &proto.Empty{}, nil
-}
-
-func (recv *ItemSnapshotterGRPCServer) AppliesTo(ctx context.Context, req *proto.ItemSnapshotterAppliesToRequest) (response *proto.ItemSnapshotterAppliesToResponse, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	resourceSelector, err := impl.AppliesTo()
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	return &proto.ItemSnapshotterAppliesToResponse{
-		ResourceSelector: &proto.ResourceSelector{
-			IncludedNamespaces: resourceSelector.IncludedNamespaces,
-			ExcludedNamespaces: resourceSelector.ExcludedNamespaces,
-			IncludedResources:  resourceSelector.IncludedResources,
-			ExcludedResources:  resourceSelector.ExcludedResources,
-			Selector:           resourceSelector.LabelSelector,
-		},
-	}, nil
-}
-
-func (recv *ItemSnapshotterGRPCServer) AlsoHandles(ctx context.Context, req *proto.AlsoHandlesRequest) (res *proto.AlsoHandlesResponse, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-	var item unstructured.Unstructured
-	var backup api.Backup
-
-	if err := json.Unmarshal(req.Item, &item); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-	if err := json.Unmarshal(req.Backup, &backup); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-	ahi := isv1.AlsoHandlesInput{
-		Item:   &item,
-		Backup: &backup,
-	}
-	alsoHandles, err := impl.AlsoHandles(&ahi)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-	res = &proto.AlsoHandlesResponse{}
-
-	for _, item := range alsoHandles {
-		res.HandledItems = append(res.HandledItems, resourceIdentifierToProto(item))
-	}
-	return res, nil
-}
-
-func (recv *ItemSnapshotterGRPCServer) SnapshotItem(ctx context.Context, req *proto.SnapshotItemRequest) (res *proto.SnapshotItemResponse, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-	var item unstructured.Unstructured
-	var backup api.Backup
-
-	if err := json.Unmarshal(req.Item, &item); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-	if err := json.Unmarshal(req.Backup, &backup); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-	sii := isv1.SnapshotItemInput{
-		Item:   &item,
-		Params: req.Params,
-		Backup: &backup,
-	}
-	sio, err := impl.SnapshotItem(ctx, &sii)
-
-	// If the plugin implementation returned a nil updatedItem (meaning no modifications), reset updatedItem to the
-	// original item.
-	var updatedItemJSON []byte
-	if sio.UpdatedItem == nil {
-		updatedItemJSON = req.Item
-	} else {
-		updatedItemJSON, err = json.Marshal(sio.UpdatedItem.UnstructuredContent())
-		if err != nil {
-			return nil, common.NewGRPCError(errors.WithStack(err))
-		}
-	}
-	res = &proto.SnapshotItemResponse{
-		Item:             updatedItemJSON,
-		SnapshotID:       sio.SnapshotID,
-		SnapshotMetadata: sio.SnapshotMetadata,
-	}
-	res.AdditionalItems = packResourceIdentifiers(sio.AdditionalItems)
-	res.HandledItems = packResourceIdentifiers(sio.HandledItems)
-	return res, err
-}
-
-func (recv *ItemSnapshotterGRPCServer) Progress(ctx context.Context, req *proto.ProgressRequest) (res *proto.ProgressResponse, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-	var backup api.Backup
-
-	if err := json.Unmarshal(req.Backup, &backup); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-	sipi := &isv1.ProgressInput{
-		ItemID:     protoToResourceIdentifier(req.ItemID),
-		SnapshotID: req.SnapshotID,
-		Backup:     &backup,
-	}
-
-	sipo, err := impl.Progress(sipi)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	res = &proto.ProgressResponse{
-		Phase:           string(sipo.Phase),
-		ItemsCompleted:  sipo.ItemsCompleted,
-		ItemsToComplete: sipo.ItemsToComplete,
-		Started:         sipo.Started.Unix(),
-		StartedNano:     sipo.Started.UnixNano(),
-		Updated:         sipo.Updated.Unix(),
-		UpdatedNano:     sipo.Updated.UnixNano(),
-		Err:             sipo.Err,
-	}
-	return res, nil
-}
-
-func (recv *ItemSnapshotterGRPCServer) DeleteSnapshot(ctx context.Context, req *proto.DeleteItemSnapshotRequest) (empty *proto.Empty, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	var itemFromBackup unstructured.Unstructured
-	if err := json.Unmarshal(req.ItemFromBackup, &itemFromBackup); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-
-	disi := isv1.DeleteSnapshotInput{
-		SnapshotID:       req.SnapshotID,
-		ItemFromBackup:   &itemFromBackup,
-		SnapshotMetadata: req.Metadata,
-		Params:           req.Params,
-	}
-
-	err = impl.DeleteSnapshot(ctx, &disi)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-	return
-}
-
-func (recv *ItemSnapshotterGRPCServer) CreateItemFromSnapshot(ctx context.Context, req *proto.CreateItemFromSnapshotRequest) (res *proto.CreateItemFromSnapshotResponse, err error) {
-	defer func() {
-		if recoveredErr := common.HandlePanic(recover()); recoveredErr != nil {
-			err = recoveredErr
-		}
-	}()
-	impl, err := recv.getImpl(req.Plugin)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	var snapshottedItem unstructured.Unstructured
-	if err := json.Unmarshal(req.Item, &snapshottedItem); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-
-	var itemFromBackup unstructured.Unstructured
-	if err := json.Unmarshal(req.Item, &itemFromBackup); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-
-	var restore api.Restore
-
-	if err := json.Unmarshal(req.Restore, &restore); err != nil {
-		return nil, common.NewGRPCError(errors.WithStack(err))
-	}
-
-	cii := isv1.CreateItemInput{
-		SnapshottedItem:  &snapshottedItem,
-		SnapshotID:       req.SnapshotID,
-		ItemFromBackup:   &itemFromBackup,
-		SnapshotMetadata: req.SnapshotMetadata,
-		Params:           req.Params,
-		Restore:          &restore,
-	}
-
-	cio, err := impl.CreateItemFromSnapshot(ctx, &cii)
-	if err != nil {
-		return nil, common.NewGRPCError(err)
-	}
-
-	var updatedItemJSON []byte
-	if cio.UpdatedItem == nil {
-		updatedItemJSON = req.Item
-	} else {
-		updatedItemJSON, err = json.Marshal(cio.UpdatedItem.UnstructuredContent())
-		if err != nil {
-			return nil, common.NewGRPCError(errors.WithStack(err))
-		}
-	}
-	res = &proto.CreateItemFromSnapshotResponse{
-		Item:        updatedItemJSON,
-		SkipRestore: cio.SkipRestore,
-	}
-	res.AdditionalItems = packResourceIdentifiers(cio.AdditionalItems)
-
-	return
-}

pkg/plugin/framework/plugin_types_test.go

@@ -30,7 +30,6 @@ func TestPluginImplementationsAreGRPCPlugins(t *testing.T) {
 		new(ObjectStorePlugin),
 		new(PluginListerPlugin),
 		new(RestoreItemActionPlugin),
-		new(ItemSnapshotterPlugin),
 	}
 
 	for _, impl := range pluginImpls {

pkg/plugin/framework/server.go

@@ -90,11 +90,6 @@ type Server interface {
 	// RegisterDeleteItemActions registers multiple Delete item actions.
 	RegisterDeleteItemActions(map[string]common.HandlerInitializer) Server
 
-	RegisterItemSnapshotter(pluginName string, initializer common.HandlerInitializer) Server
-
-	// RegisterItemSnapshotters registers multiple Item Snapshotters
-	RegisterItemSnapshotters(map[string]common.HandlerInitializer) Server
-
 	// Server runs the plugin server.
 	Serve()
 }
@@ -111,7 +106,6 @@ type server struct {
 	restoreItemAction   *RestoreItemActionPlugin
 	restoreItemActionV2 *riav2.RestoreItemActionPlugin
 	deleteItemAction    *DeleteItemActionPlugin
-	itemSnapshotter     *ItemSnapshotterPlugin
 }
 
 // NewServer returns a new Server
@@ -128,7 +122,6 @@ func NewServer() Server {
 		restoreItemAction:   NewRestoreItemActionPlugin(common.ServerLogger(log)),
 		restoreItemActionV2: riav2.NewRestoreItemActionPlugin(common.ServerLogger(log)),
 		deleteItemAction:    NewDeleteItemActionPlugin(common.ServerLogger(log)),
-		itemSnapshotter:     NewItemSnapshotterPlugin(common.ServerLogger(log)),
 	}
 }
 
@@ -224,17 +217,6 @@ func (s *server) RegisterDeleteItemActions(m map[string]common.HandlerInitialize
 	return s
 }
 
-func (s *server) RegisterItemSnapshotter(name string, initializer common.HandlerInitializer) Server {
-	s.itemSnapshotter.Register(name, initializer)
-	return s
-}
-func (s *server) RegisterItemSnapshotters(m map[string]common.HandlerInitializer) Server {
-	for name := range m {
-		s.RegisterItemSnapshotter(name, m[name])
-	}
-	return s
-}
-
 // getNames returns a list of PluginIdentifiers registered with plugin.
 func getNames(command string, kind common.PluginKind, plugin Interface) []PluginIdentifier {
 	var pluginIdentifiers []PluginIdentifier
@@ -266,7 +248,6 @@ func (s *server) Serve() {
 	pluginIdentifiers = append(pluginIdentifiers, getNames(command, common.PluginKindRestoreItemAction, s.restoreItemAction)...)
 	pluginIdentifiers = append(pluginIdentifiers, getNames(command, common.PluginKindRestoreItemActionV2, s.restoreItemActionV2)...)
 	pluginIdentifiers = append(pluginIdentifiers, getNames(command, common.PluginKindDeleteItemAction, s.deleteItemAction)...)
-	pluginIdentifiers = append(pluginIdentifiers, getNames(command, common.PluginKindItemSnapshotter, s.itemSnapshotter)...)
 
 	pluginLister := NewPluginLister(pluginIdentifiers...)
 
@@ -281,7 +262,6 @@ func (s *server) Serve() {
 			string(common.PluginKindRestoreItemAction):   s.restoreItemAction,
 			string(common.PluginKindRestoreItemActionV2): s.restoreItemActionV2,
 			string(common.PluginKindDeleteItemAction):    s.deleteItemAction,
-			string(common.PluginKindItemSnapshotter):     s.itemSnapshotter,
 		},
 		GRPCServer: plugin.DefaultGRPCServer,
 	})