Create new ItemBlockAction (IBA) plugin type

Signed-off-by: Scott Seago <[email protected]>

changelogs/unreleased/8026-sseago

@@ -0,0 +1 @@
+Created new ItemBlockAction (IBA) plugin type

pkg/plugin/clientmgmt/itemblockaction/v1/restartable_item_block_action.go

@@ -0,0 +1,115 @@
+/*
+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 v1
+
+import (
+	"github.com/pkg/errors"
+	"k8s.io/apimachinery/pkg/runtime"
+
+	api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/process"
+	"github.com/vmware-tanzu/velero/pkg/plugin/framework/common"
+	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
+	ibav1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/itemblockaction/v1"
+)
+
+// AdaptedItemBlockAction is a backup item action adapted to the v1 ItemBlockAction API
+type AdaptedItemBlockAction struct {
+	Kind common.PluginKind
+
+	// Get returns a restartable ItemBlockAction for the given name and process, wrapping if necessary
+	GetRestartable func(name string, restartableProcess process.RestartableProcess) ibav1.ItemBlockAction
+}
+
+func AdaptedItemBlockActions() []AdaptedItemBlockAction {
+	return []AdaptedItemBlockAction{
+		{
+			Kind: common.PluginKindItemBlockAction,
+			GetRestartable: func(name string, restartableProcess process.RestartableProcess) ibav1.ItemBlockAction {
+				return NewRestartableItemBlockAction(name, restartableProcess)
+			},
+		},
+	}
+}
+
+// RestartableItemBlockAction is an ItemBlock action for a given implementation (such as "pod"). It is associated with
+// a restartableProcess, which may be shared and used to run multiple plugins. At the beginning of each method
+// call, the restartableItemBlockAction asks its restartableProcess to restart itself if needed (e.g. if the
+// process terminated for any reason), then it proceeds with the actual call.
+type RestartableItemBlockAction struct {
+	Key                 process.KindAndName
+	SharedPluginProcess process.RestartableProcess
+}
+
+// NewRestartableItemBlockAction returns a new RestartableItemBlockAction.
+func NewRestartableItemBlockAction(name string, sharedPluginProcess process.RestartableProcess) *RestartableItemBlockAction {
+	r := &RestartableItemBlockAction{
+		Key:                 process.KindAndName{Kind: common.PluginKindItemBlockAction, Name: name},
+		SharedPluginProcess: sharedPluginProcess,
+	}
+	return r
+}
+
+// getItemBlockAction returns the ItemBlock action for this restartableItemBlockAction. It does *not* restart the
+// plugin process.
+func (r *RestartableItemBlockAction) getItemBlockAction() (ibav1.ItemBlockAction, error) {
+	plugin, err := r.SharedPluginProcess.GetByKindAndName(r.Key)
+	if err != nil {
+		return nil, err
+	}
+
+	backupItemAction, ok := plugin.(ibav1.ItemBlockAction)
+	if !ok {
+		return nil, errors.Errorf("plugin %T is not an ItemBlockAction", plugin)
+	}
+
+	return backupItemAction, nil
+}
+
+// getDelegate restarts the plugin process (if needed) and returns the backup item action for this restartableItemBlockAction.
+func (r *RestartableItemBlockAction) getDelegate() (ibav1.ItemBlockAction, error) {
+	if err := r.SharedPluginProcess.ResetIfNeeded(); err != nil {
+		return nil, err
+	}
+
+	return r.getItemBlockAction()
+}
+
+// Name returns the plugin's name.
+func (r *RestartableItemBlockAction) Name() string {
+	return r.Key.Name
+}
+
+// AppliesTo restarts the plugin's process if needed, then delegates the call.
+func (r *RestartableItemBlockAction) AppliesTo() (velero.ResourceSelector, error) {
+	delegate, err := r.getDelegate()
+	if err != nil {
+		return velero.ResourceSelector{}, err
+	}
+
+	return delegate.AppliesTo()
+}
+
+// GetRelatedItems restarts the plugin's process if needed, then delegates the call.
+func (r *RestartableItemBlockAction) GetRelatedItems(item runtime.Unstructured, backup *api.Backup) ([]velero.ResourceIdentifier, error) {
+	delegate, err := r.getDelegate()
+	if err != nil {
+		return nil, err
+	}
+
+	return delegate.GetRelatedItems(item, backup)
+}

pkg/plugin/clientmgmt/itemblockaction/v1/restartable_item_block_action_test.go

@@ -0,0 +1,144 @@
+/*
+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 v1
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	"github.com/vmware-tanzu/velero/internal/restartabletest"
+	v1 "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/process"
+	"github.com/vmware-tanzu/velero/pkg/plugin/framework/common"
+	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
+	mocks "github.com/vmware-tanzu/velero/pkg/plugin/velero/mocks/itemblockaction/v1"
+)
+
+func TestRestartableGetItemBlockAction(t *testing.T) {
+	tests := []struct {
+		name          string
+		plugin        interface{}
+		getError      error
+		expectedError string
+	}{
+		{
+			name:          "error getting by kind and name",
+			getError:      errors.Errorf("get error"),
+			expectedError: "get error",
+		},
+		{
+			name:          "wrong type",
+			plugin:        3,
+			expectedError: "plugin int is not an ItemBlockAction",
+		},
+		{
+			name:   "happy path",
+			plugin: new(mocks.ItemBlockAction),
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			p := new(restartabletest.MockRestartableProcess)
+			defer p.AssertExpectations(t)
+
+			name := "pod"
+			key := process.KindAndName{Kind: common.PluginKindItemBlockAction, Name: name}
+			p.On("GetByKindAndName", key).Return(tc.plugin, tc.getError)
+
+			r := NewRestartableItemBlockAction(name, p)
+			a, err := r.getItemBlockAction()
+			if tc.expectedError != "" {
+				assert.EqualError(t, err, tc.expectedError)
+				return
+			}
+			require.NoError(t, err)
+
+			assert.Equal(t, tc.plugin, a)
+		})
+	}
+}
+
+func TestRestartableItemBlockActionGetDelegate(t *testing.T) {
+	p := new(restartabletest.MockRestartableProcess)
+	defer p.AssertExpectations(t)
+
+	// Reset error
+	p.On("ResetIfNeeded").Return(errors.Errorf("reset error")).Once()
+	name := "pod"
+	r := NewRestartableItemBlockAction(name, p)
+	a, err := r.getDelegate()
+	assert.Nil(t, a)
+	assert.EqualError(t, err, "reset error")
+
+	// Happy path
+	p.On("ResetIfNeeded").Return(nil)
+	expected := new(mocks.ItemBlockAction)
+	key := process.KindAndName{Kind: common.PluginKindItemBlockAction, Name: name}
+	p.On("GetByKindAndName", key).Return(expected, nil)
+
+	a, err = r.getDelegate()
+	assert.NoError(t, err)
+	assert.Equal(t, expected, a)
+}
+
+func TestRestartableItemBlockActionDelegatedFunctions(t *testing.T) {
+	b := new(v1.Backup)
+
+	pv := &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"color": "blue",
+		},
+	}
+
+	relatedItems := []velero.ResourceIdentifier{
+		{
+			GroupResource: schema.GroupResource{Group: "velero.io", Resource: "backups"},
+		},
+	}
+
+	restartabletest.RunRestartableDelegateTests(
+		t,
+		common.PluginKindItemBlockAction,
+		func(key process.KindAndName, p process.RestartableProcess) interface{} {
+			return &RestartableItemBlockAction{
+				Key:                 key,
+				SharedPluginProcess: p,
+			}
+		},
+		func() restartabletest.Mockable {
+			return new(mocks.ItemBlockAction)
+		},
+		restartabletest.RestartableDelegateTest{
+			Function:                "AppliesTo",
+			Inputs:                  []interface{}{},
+			ExpectedErrorOutputs:    []interface{}{velero.ResourceSelector{}, errors.Errorf("reset error")},
+			ExpectedDelegateOutputs: []interface{}{velero.ResourceSelector{IncludedNamespaces: []string{"a"}}, errors.Errorf("delegate error")},
+		},
+		restartabletest.RestartableDelegateTest{
+			Function:                "GetRelatedItems",
+			Inputs:                  []interface{}{pv, b},
+			ExpectedErrorOutputs:    []interface{}{([]velero.ResourceIdentifier)(nil), errors.Errorf("reset error")},
+			ExpectedDelegateOutputs: []interface{}{relatedItems, errors.Errorf("delegate error")},
+		},
+	)
+}

pkg/plugin/clientmgmt/manager.go

@@ -26,6 +26,7 @@ import (
 
 	biav1cli "github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/backupitemaction/v1"
 	biav2cli "github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/backupitemaction/v2"
+	ibav1cli "github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/itemblockaction/v1"
 	"github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/process"
 	riav1cli "github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/restoreitemaction/v1"
 	riav2cli "github.com/vmware-tanzu/velero/pkg/plugin/clientmgmt/restoreitemaction/v2"
@@ -34,6 +35,7 @@ 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"
+	ibav1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/itemblockaction/v1"
 	riav1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/restoreitemaction/v1"
 	riav2 "github.com/vmware-tanzu/velero/pkg/plugin/velero/restoreitemaction/v2"
 	vsv1 "github.com/vmware-tanzu/velero/pkg/plugin/velero/volumesnapshotter/v1"
@@ -77,6 +79,12 @@ type Manager interface {
 	// GetDeleteItemAction returns the delete item action plugin for name.
 	GetDeleteItemAction(name string) (velero.DeleteItemAction, error)
 
+	// GetItemBlockActions returns all v1 ItemBlock action plugins.
+	GetItemBlockActions() ([]ibav1.ItemBlockAction, error)
+
+	// GetItemBlockAction returns the ItemBlock action plugin for name.
+	GetItemBlockAction(name string) (ibav1.ItemBlockAction, error)
+
 	// CleanupClients terminates all of the Manager's running plugin processes.
 	CleanupClients()
 }
@@ -374,6 +382,44 @@ func (m *manager) GetDeleteItemAction(name string) (velero.DeleteItemAction, err
 	return r, nil
 }
 
+// GetItemBlockActions returns all ItemBlock actions as restartableItemBlockActions.
+func (m *manager) GetItemBlockActions() ([]ibav1.ItemBlockAction, error) {
+	list := m.registry.List(common.PluginKindItemBlockAction)
+
+	actions := make([]ibav1.ItemBlockAction, 0, len(list))
+
+	for i := range list {
+		id := list[i]
+
+		r, err := m.GetItemBlockAction(id.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		actions = append(actions, r)
+	}
+
+	return actions, nil
+}
+
+// GetItemBlockAction returns a restartableItemBlockAction for name.
+func (m *manager) GetItemBlockAction(name string) (ibav1.ItemBlockAction, error) {
+	name = sanitizeName(name)
+
+	for _, adaptedItemBlockAction := range ibav1cli.AdaptedItemBlockActions() {
+		restartableProcess, err := m.getRestartableProcess(adaptedItemBlockAction.Kind, name)
+		// Check if plugin was not found
+		if errors.As(err, &pluginNotFoundErrType) {
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+		return adaptedItemBlockAction.GetRestartable(name, restartableProcess), nil
+	}
+	return nil, fmt.Errorf("unable to get valid ItemBlockAction for %q", name)
+}
+
 // sanitizeName adds "velero.io" to legacy plugins that weren't namespaced.
 func sanitizeName(name string) string {
 	// Backwards compatibility with non-namespaced Velero plugins, following principle of least surprise