Merge pull request #9892 from Lyndon-Li/refactor-generic-exposer-interface

Enhance RebindVolume method for generic restore exposer

changelogs/unreleased/9892-Lyndon-Li

@@ -0,0 +1 @@
+Enhance RebindVolume method for generic restore exposer to support block data mover

pkg/controller/data_download_controller.go

@@ -475,7 +475,11 @@ func (r *DataDownloadReconciler) OnDataDownloadCompleted(ctx context.Context, na
 	}
 
 	objRef := getDataDownloadOwnerObject(&dd)
-	err := r.restoreExposer.RebindVolume(ctx, objRef, dd.Spec.TargetVolume.PVC, dd.Spec.TargetVolume.Namespace, dd.Spec.OperationTimeout.Duration)
+	err := r.restoreExposer.RebindVolume(ctx, objRef, exposer.GenericRestoreRebindVolumeParam{
+		TargetPVCName:    dd.Spec.TargetVolume.PVC,
+		TargetNamespace:  dd.Spec.TargetVolume.Namespace,
+		OperationTimeout: dd.Spec.OperationTimeout.Duration,
+	})
 	if err != nil {
 		log.WithError(err).Error("Failed to rebind PV to target PVC on completion")
 		return

pkg/controller/data_download_controller_test.go

@@ -548,7 +548,7 @@ func TestDataDownloadReconcile(t *testing.T) {
 					r.restoreExposer = nil
 				} else {
 					r.restoreExposer = func() exposer.GenericRestoreExposer {
-						ep := exposermockes.NewMockGenericRestoreExposer(t)
+						ep := exposermockes.NewGenericRestoreExposer(t)
 						if test.isExposeErr {
 							ep.On("Expose", mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to expose restore exposer"))
 						} else if test.notNilExpose {
@@ -712,7 +712,7 @@ func TestOnDataDownloadCompleted(t *testing.T) {
 			needErrs := []bool{test.isGetErr, false, false, false}
 			r, err := initDataDownloadReconciler(t, nil, needErrs...)
 			r.restoreExposer = func() exposer.GenericRestoreExposer {
-				ep := exposermockes.NewMockGenericRestoreExposer(t)
+				ep := exposermockes.NewGenericRestoreExposer(t)
 				if test.rebindVolumeErr {
 					ep.On("RebindVolume", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("Error to rebind volume"))
 				} else {
@@ -1092,7 +1092,7 @@ func (dt *ddResumeTestHelper) DiagnoseExpose(context.Context, corev1api.ObjectRe
 	return ""
 }
 
-func (dt *ddResumeTestHelper) RebindVolume(context.Context, corev1api.ObjectReference, string, string, time.Duration) error {
+func (dt *ddResumeTestHelper) RebindVolume(context.Context, corev1api.ObjectReference, exposer.GenericRestoreRebindVolumeParam) error {
 	return nil
 }
 

pkg/exposer/generic_restore.go

@@ -81,6 +81,18 @@ type GenericRestoreExposeParam struct {
 	CacheVolume *CacheConfigs
 }
 
+// GenericRestoreRebindVolumeParam define the input param for Generic Restore Rebind Volume
+type GenericRestoreRebindVolumeParam struct {
+	// TargetPVCName is the target volume name to be restored
+	TargetPVCName string
+
+	// TargetNamespace is the namespace of the volume to be restored
+	TargetNamespace string
+
+	// OperationTimeout specifies the time wait for resources operations in Expose
+	OperationTimeout time.Duration
+}
+
 // GenericRestoreExposer is the interfaces for a generic restore exposer
 type GenericRestoreExposer interface {
 	// Expose starts the process to a restore expose, the expose process may take long time
@@ -101,7 +113,7 @@ type GenericRestoreExposer interface {
 	DiagnoseExpose(context.Context, corev1api.ObjectReference) string
 
 	// RebindVolume unexposes the restored PV and rebind it to the target PVC
-	RebindVolume(context.Context, corev1api.ObjectReference, string, string, time.Duration) error
+	RebindVolume(context.Context, corev1api.ObjectReference, GenericRestoreRebindVolumeParam) error
 
 	// CleanUp cleans up any objects generated during the restore expose
 	CleanUp(context.Context, corev1api.ObjectReference)
@@ -379,22 +391,22 @@ func (e *genericRestoreExposer) CleanUp(ctx context.Context, ownerObject corev1a
 	kube.DeletePVAndPVCIfAny(ctx, e.kubeClient.CoreV1(), cachePVCName, ownerObject.Namespace, 0, e.log)
 }
 
-func (e *genericRestoreExposer) RebindVolume(ctx context.Context, ownerObject corev1api.ObjectReference, targetPVCName string, targetNamespace string, timeout time.Duration) error {
+func (e *genericRestoreExposer) RebindVolume(ctx context.Context, ownerObject corev1api.ObjectReference, param GenericRestoreRebindVolumeParam) error {
 	restorePodName := ownerObject.Name
 	restorePVCName := ownerObject.Name
 
 	curLog := e.log.WithFields(logrus.Fields{
 		"owner":            ownerObject.Name,
-		"target PVC":       targetPVCName,
-		"target namespace": targetNamespace,
+		"target PVC":       param.TargetPVCName,
+		"target namespace": param.TargetNamespace,
 	})
 
-	targetPVC, err := e.kubeClient.CoreV1().PersistentVolumeClaims(targetNamespace).Get(ctx, targetPVCName, metav1.GetOptions{})
+	targetPVC, err := e.kubeClient.CoreV1().PersistentVolumeClaims(param.TargetNamespace).Get(ctx, param.TargetPVCName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrapf(err, "error to get target PVC %s/%s", targetNamespace, targetPVCName)
+		return errors.Wrapf(err, "error to get target PVC %s/%s", param.TargetNamespace, param.TargetPVCName)
 	}
 
-	restorePV, err := kube.WaitPVCBound(ctx, e.kubeClient.CoreV1(), e.kubeClient.CoreV1(), restorePVCName, ownerObject.Namespace, timeout)
+	restorePV, err := kube.WaitPVCBound(ctx, e.kubeClient.CoreV1(), e.kubeClient.CoreV1(), restorePVCName, ownerObject.Namespace, param.OperationTimeout)
 	if err != nil {
 		return errors.Wrapf(err, "error to get PV from restore PVC %s", restorePVCName)
 	}
@@ -421,12 +433,12 @@ func (e *genericRestoreExposer) RebindVolume(ctx context.Context, ownerObject co
 		restorePV = retained
 	}
 
-	err = kube.EnsureDeletePod(ctx, e.kubeClient.CoreV1(), restorePodName, ownerObject.Namespace, timeout)
+	err = kube.EnsureDeletePod(ctx, e.kubeClient.CoreV1(), restorePodName, ownerObject.Namespace, param.OperationTimeout)
 	if err != nil {
 		return errors.Wrapf(err, "error to delete restore pod %s", restorePodName)
 	}
 
-	err = kube.EnsureDeletePVC(ctx, e.kubeClient.CoreV1(), restorePVCName, ownerObject.Namespace, timeout)
+	err = kube.EnsureDeletePVC(ctx, e.kubeClient.CoreV1(), restorePVCName, ownerObject.Namespace, param.OperationTimeout)
 	if err != nil {
 		return errors.Wrapf(err, "error to delete restore PVC %s", restorePVCName)
 	}
@@ -453,7 +465,7 @@ func (e *genericRestoreExposer) RebindVolume(ctx context.Context, ownerObject co
 
 	curLog.WithField("restore PV", restorePV.Name).Info("Restore PV is rebound")
 
-	restorePV, err = kube.WaitPVBound(ctx, e.kubeClient.CoreV1(), restorePV.Name, targetPVC.Name, targetPVC.Namespace, timeout)
+	restorePV, err = kube.WaitPVBound(ctx, e.kubeClient.CoreV1(), restorePV.Name, targetPVC.Name, targetPVC.Namespace, param.OperationTimeout)
 	if err != nil {
 		return errors.Wrapf(err, "error to wait restore PV bound, restore PV %s", restorePVName)
 	}

pkg/exposer/generic_restore_test.go

@@ -535,7 +535,11 @@ func TestRebindVolume(t *testing.T) {
 
 			hookCount = 0
 
-			err := exposer.RebindVolume(t.Context(), ownerObject, test.targetPVCName, test.targetNamespace, time.Millisecond)
+			err := exposer.RebindVolume(t.Context(), ownerObject, GenericRestoreRebindVolumeParam{
+				TargetPVCName:    test.targetPVCName,
+				TargetNamespace:  test.targetNamespace,
+				OperationTimeout: time.Millisecond,
+			})
 			assert.EqualError(t, err, test.err)
 		})
 	}

pkg/exposer/mocks/GenericRestoreExposer.go

@@ -14,13 +14,13 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-// NewMockGenericRestoreExposer creates a new instance of MockGenericRestoreExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// NewGenericRestoreExposer creates a new instance of GenericRestoreExposer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockGenericRestoreExposer(t interface {
+func NewGenericRestoreExposer(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockGenericRestoreExposer {
-	mock := &MockGenericRestoreExposer{}
+}) *GenericRestoreExposer {
+	mock := &GenericRestoreExposer{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })
@@ -28,38 +28,38 @@ func NewMockGenericRestoreExposer(t interface {
 	return mock
 }
 
-// MockGenericRestoreExposer is an autogenerated mock type for the GenericRestoreExposer type
-type MockGenericRestoreExposer struct {
+// GenericRestoreExposer is an autogenerated mock type for the GenericRestoreExposer type
+type GenericRestoreExposer struct {
 	mock.Mock
 }
 
-type MockGenericRestoreExposer_Expecter struct {
+type GenericRestoreExposer_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockGenericRestoreExposer) EXPECT() *MockGenericRestoreExposer_Expecter {
-	return &MockGenericRestoreExposer_Expecter{mock: &_m.Mock}
+func (_m *GenericRestoreExposer) EXPECT() *GenericRestoreExposer_Expecter {
+	return &GenericRestoreExposer_Expecter{mock: &_m.Mock}
 }
 
-// CleanUp provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) CleanUp(context1 context.Context, objectReference v1.ObjectReference) {
+// CleanUp provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) CleanUp(context1 context.Context, objectReference v1.ObjectReference) {
 	_mock.Called(context1, objectReference)
 	return
 }
 
-// MockGenericRestoreExposer_CleanUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanUp'
-type MockGenericRestoreExposer_CleanUp_Call struct {
+// GenericRestoreExposer_CleanUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanUp'
+type GenericRestoreExposer_CleanUp_Call struct {
 	*mock.Call
 }
 
 // CleanUp is a helper method to define mock.On call
 //   - context1 context.Context
 //   - objectReference v1.ObjectReference
-func (_e *MockGenericRestoreExposer_Expecter) CleanUp(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_CleanUp_Call {
-	return &MockGenericRestoreExposer_CleanUp_Call{Call: _e.mock.On("CleanUp", context1, objectReference)}
+func (_e *GenericRestoreExposer_Expecter) CleanUp(context1 interface{}, objectReference interface{}) *GenericRestoreExposer_CleanUp_Call {
+	return &GenericRestoreExposer_CleanUp_Call{Call: _e.mock.On("CleanUp", context1, objectReference)}
 }
 
-func (_c *MockGenericRestoreExposer_CleanUp_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_CleanUp_Call {
+func (_c *GenericRestoreExposer_CleanUp_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *GenericRestoreExposer_CleanUp_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -77,18 +77,18 @@ func (_c *MockGenericRestoreExposer_CleanUp_Call) Run(run func(context1 context.
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_CleanUp_Call) Return() *MockGenericRestoreExposer_CleanUp_Call {
+func (_c *GenericRestoreExposer_CleanUp_Call) Return() *GenericRestoreExposer_CleanUp_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_CleanUp_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_CleanUp_Call {
+func (_c *GenericRestoreExposer_CleanUp_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference)) *GenericRestoreExposer_CleanUp_Call {
 	_c.Run(run)
 	return _c
 }
 
-// DiagnoseExpose provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) DiagnoseExpose(context1 context.Context, objectReference v1.ObjectReference) string {
+// DiagnoseExpose provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) DiagnoseExpose(context1 context.Context, objectReference v1.ObjectReference) string {
 	ret := _mock.Called(context1, objectReference)
 
 	if len(ret) == 0 {
@@ -104,19 +104,19 @@ func (_mock *MockGenericRestoreExposer) DiagnoseExpose(context1 context.Context,
 	return r0
 }
 
-// MockGenericRestoreExposer_DiagnoseExpose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiagnoseExpose'
-type MockGenericRestoreExposer_DiagnoseExpose_Call struct {
+// GenericRestoreExposer_DiagnoseExpose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiagnoseExpose'
+type GenericRestoreExposer_DiagnoseExpose_Call struct {
 	*mock.Call
 }
 
 // DiagnoseExpose is a helper method to define mock.On call
 //   - context1 context.Context
 //   - objectReference v1.ObjectReference
-func (_e *MockGenericRestoreExposer_Expecter) DiagnoseExpose(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_DiagnoseExpose_Call {
-	return &MockGenericRestoreExposer_DiagnoseExpose_Call{Call: _e.mock.On("DiagnoseExpose", context1, objectReference)}
+func (_e *GenericRestoreExposer_Expecter) DiagnoseExpose(context1 interface{}, objectReference interface{}) *GenericRestoreExposer_DiagnoseExpose_Call {
+	return &GenericRestoreExposer_DiagnoseExpose_Call{Call: _e.mock.On("DiagnoseExpose", context1, objectReference)}
 }
 
-func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_DiagnoseExpose_Call {
+func (_c *GenericRestoreExposer_DiagnoseExpose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *GenericRestoreExposer_DiagnoseExpose_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -134,18 +134,18 @@ func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) Run(run func(context1 c
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) Return(s string) *MockGenericRestoreExposer_DiagnoseExpose_Call {
+func (_c *GenericRestoreExposer_DiagnoseExpose_Call) Return(s string) *GenericRestoreExposer_DiagnoseExpose_Call {
 	_c.Call.Return(s)
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_DiagnoseExpose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) string) *MockGenericRestoreExposer_DiagnoseExpose_Call {
+func (_c *GenericRestoreExposer_DiagnoseExpose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) string) *GenericRestoreExposer_DiagnoseExpose_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// Expose provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) Expose(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error {
+// Expose provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) Expose(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error {
 	ret := _mock.Called(context1, objectReference, genericRestoreExposeParam)
 
 	if len(ret) == 0 {
@@ -161,8 +161,8 @@ func (_mock *MockGenericRestoreExposer) Expose(context1 context.Context, objectR
 	return r0
 }
 
-// MockGenericRestoreExposer_Expose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expose'
-type MockGenericRestoreExposer_Expose_Call struct {
+// GenericRestoreExposer_Expose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Expose'
+type GenericRestoreExposer_Expose_Call struct {
 	*mock.Call
 }
 
@@ -170,11 +170,11 @@ type MockGenericRestoreExposer_Expose_Call struct {
 //   - context1 context.Context
 //   - objectReference v1.ObjectReference
 //   - genericRestoreExposeParam exposer.GenericRestoreExposeParam
-func (_e *MockGenericRestoreExposer_Expecter) Expose(context1 interface{}, objectReference interface{}, genericRestoreExposeParam interface{}) *MockGenericRestoreExposer_Expose_Call {
-	return &MockGenericRestoreExposer_Expose_Call{Call: _e.mock.On("Expose", context1, objectReference, genericRestoreExposeParam)}
+func (_e *GenericRestoreExposer_Expecter) Expose(context1 interface{}, objectReference interface{}, genericRestoreExposeParam interface{}) *GenericRestoreExposer_Expose_Call {
+	return &GenericRestoreExposer_Expose_Call{Call: _e.mock.On("Expose", context1, objectReference, genericRestoreExposeParam)}
 }
 
-func (_c *MockGenericRestoreExposer_Expose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam)) *MockGenericRestoreExposer_Expose_Call {
+func (_c *GenericRestoreExposer_Expose_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam)) *GenericRestoreExposer_Expose_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -197,18 +197,18 @@ func (_c *MockGenericRestoreExposer_Expose_Call) Run(run func(context1 context.C
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_Expose_Call) Return(err error) *MockGenericRestoreExposer_Expose_Call {
+func (_c *GenericRestoreExposer_Expose_Call) Return(err error) *GenericRestoreExposer_Expose_Call {
 	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_Expose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error) *MockGenericRestoreExposer_Expose_Call {
+func (_c *GenericRestoreExposer_Expose_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreExposeParam exposer.GenericRestoreExposeParam) error) *GenericRestoreExposer_Expose_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// GetExposed provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) GetExposed(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error) {
+// GetExposed provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) GetExposed(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error) {
 	ret := _mock.Called(context1, objectReference, client1, s, duration)
 
 	if len(ret) == 0 {
@@ -235,8 +235,8 @@ func (_mock *MockGenericRestoreExposer) GetExposed(context1 context.Context, obj
 	return r0, r1
 }
 
-// MockGenericRestoreExposer_GetExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExposed'
-type MockGenericRestoreExposer_GetExposed_Call struct {
+// GenericRestoreExposer_GetExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetExposed'
+type GenericRestoreExposer_GetExposed_Call struct {
 	*mock.Call
 }
 
@@ -246,11 +246,11 @@ type MockGenericRestoreExposer_GetExposed_Call struct {
 //   - client1 client.Client
 //   - s string
 //   - duration time.Duration
-func (_e *MockGenericRestoreExposer_Expecter) GetExposed(context1 interface{}, objectReference interface{}, client1 interface{}, s interface{}, duration interface{}) *MockGenericRestoreExposer_GetExposed_Call {
-	return &MockGenericRestoreExposer_GetExposed_Call{Call: _e.mock.On("GetExposed", context1, objectReference, client1, s, duration)}
+func (_e *GenericRestoreExposer_Expecter) GetExposed(context1 interface{}, objectReference interface{}, client1 interface{}, s interface{}, duration interface{}) *GenericRestoreExposer_GetExposed_Call {
+	return &GenericRestoreExposer_GetExposed_Call{Call: _e.mock.On("GetExposed", context1, objectReference, client1, s, duration)}
 }
 
-func (_c *MockGenericRestoreExposer_GetExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration)) *MockGenericRestoreExposer_GetExposed_Call {
+func (_c *GenericRestoreExposer_GetExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration)) *GenericRestoreExposer_GetExposed_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -283,18 +283,18 @@ func (_c *MockGenericRestoreExposer_GetExposed_Call) Run(run func(context1 conte
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_GetExposed_Call) Return(exposeResult *exposer.ExposeResult, err error) *MockGenericRestoreExposer_GetExposed_Call {
+func (_c *GenericRestoreExposer_GetExposed_Call) Return(exposeResult *exposer.ExposeResult, err error) *GenericRestoreExposer_GetExposed_Call {
 	_c.Call.Return(exposeResult, err)
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_GetExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error)) *MockGenericRestoreExposer_GetExposed_Call {
+func (_c *GenericRestoreExposer_GetExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, client1 client.Client, s string, duration time.Duration) (*exposer.ExposeResult, error)) *GenericRestoreExposer_GetExposed_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// PeekExposed provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) PeekExposed(context1 context.Context, objectReference v1.ObjectReference) error {
+// PeekExposed provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) PeekExposed(context1 context.Context, objectReference v1.ObjectReference) error {
 	ret := _mock.Called(context1, objectReference)
 
 	if len(ret) == 0 {
@@ -310,19 +310,19 @@ func (_mock *MockGenericRestoreExposer) PeekExposed(context1 context.Context, ob
 	return r0
 }
 
-// MockGenericRestoreExposer_PeekExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PeekExposed'
-type MockGenericRestoreExposer_PeekExposed_Call struct {
+// GenericRestoreExposer_PeekExposed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PeekExposed'
+type GenericRestoreExposer_PeekExposed_Call struct {
 	*mock.Call
 }
 
 // PeekExposed is a helper method to define mock.On call
 //   - context1 context.Context
 //   - objectReference v1.ObjectReference
-func (_e *MockGenericRestoreExposer_Expecter) PeekExposed(context1 interface{}, objectReference interface{}) *MockGenericRestoreExposer_PeekExposed_Call {
-	return &MockGenericRestoreExposer_PeekExposed_Call{Call: _e.mock.On("PeekExposed", context1, objectReference)}
+func (_e *GenericRestoreExposer_Expecter) PeekExposed(context1 interface{}, objectReference interface{}) *GenericRestoreExposer_PeekExposed_Call {
+	return &GenericRestoreExposer_PeekExposed_Call{Call: _e.mock.On("PeekExposed", context1, objectReference)}
 }
 
-func (_c *MockGenericRestoreExposer_PeekExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *MockGenericRestoreExposer_PeekExposed_Call {
+func (_c *GenericRestoreExposer_PeekExposed_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference)) *GenericRestoreExposer_PeekExposed_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -340,49 +340,47 @@ func (_c *MockGenericRestoreExposer_PeekExposed_Call) Run(run func(context1 cont
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_PeekExposed_Call) Return(err error) *MockGenericRestoreExposer_PeekExposed_Call {
+func (_c *GenericRestoreExposer_PeekExposed_Call) Return(err error) *GenericRestoreExposer_PeekExposed_Call {
 	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_PeekExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) error) *MockGenericRestoreExposer_PeekExposed_Call {
+func (_c *GenericRestoreExposer_PeekExposed_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference) error) *GenericRestoreExposer_PeekExposed_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// RebindVolume provides a mock function for the type MockGenericRestoreExposer
-func (_mock *MockGenericRestoreExposer) RebindVolume(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration) error {
-	ret := _mock.Called(context1, objectReference, s, s1, duration)
+// RebindVolume provides a mock function for the type GenericRestoreExposer
+func (_mock *GenericRestoreExposer) RebindVolume(context1 context.Context, objectReference v1.ObjectReference, genericRestoreRebindVolumeParam exposer.GenericRestoreRebindVolumeParam) error {
+	ret := _mock.Called(context1, objectReference, genericRestoreRebindVolumeParam)
 
 	if len(ret) == 0 {
 		panic("no return value specified for RebindVolume")
 	}
 
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, string, string, time.Duration) error); ok {
-		r0 = returnFunc(context1, objectReference, s, s1, duration)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, v1.ObjectReference, exposer.GenericRestoreRebindVolumeParam) error); ok {
+		r0 = returnFunc(context1, objectReference, genericRestoreRebindVolumeParam)
 	} else {
 		r0 = ret.Error(0)
 	}
 	return r0
 }
 
-// MockGenericRestoreExposer_RebindVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebindVolume'
-type MockGenericRestoreExposer_RebindVolume_Call struct {
+// GenericRestoreExposer_RebindVolume_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebindVolume'
+type GenericRestoreExposer_RebindVolume_Call struct {
 	*mock.Call
 }
 
 // RebindVolume is a helper method to define mock.On call
 //   - context1 context.Context
 //   - objectReference v1.ObjectReference
-//   - s string
-//   - s1 string
-//   - duration time.Duration
-func (_e *MockGenericRestoreExposer_Expecter) RebindVolume(context1 interface{}, objectReference interface{}, s interface{}, s1 interface{}, duration interface{}) *MockGenericRestoreExposer_RebindVolume_Call {
-	return &MockGenericRestoreExposer_RebindVolume_Call{Call: _e.mock.On("RebindVolume", context1, objectReference, s, s1, duration)}
+//   - genericRestoreRebindVolumeParam exposer.GenericRestoreRebindVolumeParam
+func (_e *GenericRestoreExposer_Expecter) RebindVolume(context1 interface{}, objectReference interface{}, genericRestoreRebindVolumeParam interface{}) *GenericRestoreExposer_RebindVolume_Call {
+	return &GenericRestoreExposer_RebindVolume_Call{Call: _e.mock.On("RebindVolume", context1, objectReference, genericRestoreRebindVolumeParam)}
 }
 
-func (_c *MockGenericRestoreExposer_RebindVolume_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration)) *MockGenericRestoreExposer_RebindVolume_Call {
+func (_c *GenericRestoreExposer_RebindVolume_Call) Run(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreRebindVolumeParam exposer.GenericRestoreRebindVolumeParam)) *GenericRestoreExposer_RebindVolume_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -392,35 +390,25 @@ func (_c *MockGenericRestoreExposer_RebindVolume_Call) Run(run func(context1 con
 		if args[1] != nil {
 			arg1 = args[1].(v1.ObjectReference)
 		}
-		var arg2 string
+		var arg2 exposer.GenericRestoreRebindVolumeParam
 		if args[2] != nil {
-			arg2 = args[2].(string)
-		}
-		var arg3 string
-		if args[3] != nil {
-			arg3 = args[3].(string)
-		}
-		var arg4 time.Duration
-		if args[4] != nil {
-			arg4 = args[4].(time.Duration)
+			arg2 = args[2].(exposer.GenericRestoreRebindVolumeParam)
 		}
 		run(
 			arg0,
 			arg1,
 			arg2,
-			arg3,
-			arg4,
 		)
 	})
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_RebindVolume_Call) Return(err error) *MockGenericRestoreExposer_RebindVolume_Call {
+func (_c *GenericRestoreExposer_RebindVolume_Call) Return(err error) *GenericRestoreExposer_RebindVolume_Call {
 	_c.Call.Return(err)
 	return _c
 }
 
-func (_c *MockGenericRestoreExposer_RebindVolume_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, s string, s1 string, duration time.Duration) error) *MockGenericRestoreExposer_RebindVolume_Call {
+func (_c *GenericRestoreExposer_RebindVolume_Call) RunAndReturn(run func(context1 context.Context, objectReference v1.ObjectReference, genericRestoreRebindVolumeParam exposer.GenericRestoreRebindVolumeParam) error) *GenericRestoreExposer_RebindVolume_Call {
 	_c.Call.Return(run)
 	return _c
 }