refactor: split parts of the adapter as owned.State

The idea is to split the part which enforces the ownership (but skip
things like rate-limiting protection and controller-specific access
checks) into a separate package which has exactly same interface.

This allows one to easily build a `controller.Reader/Writer` out of
`state.State` (e.g. in the unit-tests).

Signed-off-by: Andrey Smirnov <[email protected]>

Author: smira

pkg/controller/runtime.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/cosi-project/runtime/pkg/resource"
 	"github.com/cosi-project/runtime/pkg/state"
+	"github.com/cosi-project/runtime/pkg/state/owned"
 )
 
 // ReconcileEvent is a signal for controller to reconcile its resources.
@@ -111,11 +112,7 @@ type Output struct {
 // Reader provides read-only access to the state.
 //
 // Interface [state.State] also satisfies this interface.
-type Reader interface {
-	Get(context.Context, resource.Pointer, ...state.GetOption) (resource.Resource, error)
-	List(context.Context, resource.Kind, ...state.ListOption) (resource.List, error)
-	ContextWithTeardown(context.Context, resource.Pointer) (context.Context, error)
-}
+type Reader = owned.Reader
 
 // UncachedReader provides read-only access to the state without cache.
 //
@@ -128,23 +125,10 @@ type UncachedReader interface {
 // Writer provides write access to the state.
 //
 // Only output objects can be written to by the controller.
-type Writer interface {
-	Create(context.Context, resource.Resource) error
-	Update(context.Context, resource.Resource) error
-	Modify(context.Context, resource.Resource, func(resource.Resource) error, ...ModifyOption) error
-	ModifyWithResult(context.Context, resource.Resource, func(resource.Resource) error, ...ModifyOption) (resource.Resource, error)
-	Teardown(context.Context, resource.Pointer, ...DeleteOption) (bool, error)
-	Destroy(context.Context, resource.Pointer, ...DeleteOption) error
-
-	AddFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error
-	RemoveFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error
-}
+type Writer = owned.Writer
 
 // ReaderWriter combines Reader and Writer interfaces.
-type ReaderWriter interface {
-	Reader
-	Writer
-}
+type ReaderWriter = owned.ReaderWriter
 
 // OutputTracker provides automatic cleanup of the outputs based on the calls to Modify function.
 //
@@ -159,64 +143,22 @@ type OutputTracker interface {
 }
 
 // DeleteOption for operation Teardown/Destroy.
-type DeleteOption func(*DeleteOptions)
-
-// DeleteOptions for operation Teardown/Destroy.
-type DeleteOptions struct {
-	Owner *string
-}
+type DeleteOption = owned.DeleteOption
 
 // WithOwner allows to specify owner of the resource.
 func WithOwner(owner string) DeleteOption {
-	return func(o *DeleteOptions) {
-		o.Owner = &owner
-	}
-}
-
-// ToDeleteOptions converts variadic options to DeleteOptions.
-func ToDeleteOptions(opts ...DeleteOption) DeleteOptions {
-	var options DeleteOptions
-
-	for _, opt := range opts {
-		opt(&options)
-	}
-
-	return options
+	return owned.WithOwner(owner)
 }
 
 // ModifyOption for operation Modify.
-type ModifyOption func(*ModifyOptions)
-
-// ModifyOptions for operation Modify.
-type ModifyOptions struct {
-	ExpectedPhase *resource.Phase
-}
+type ModifyOption = owned.ModifyOption
 
 // WithExpectedPhase allows to specify expected phase of the resource.
 func WithExpectedPhase(phase resource.Phase) ModifyOption {
-	return func(o *ModifyOptions) {
-		o.ExpectedPhase = &phase
-	}
+	return owned.WithExpectedPhase(phase)
 }
 
 // WithExpectedPhaseAny allows to specify any phase of the resource.
 func WithExpectedPhaseAny() ModifyOption {
-	return func(o *ModifyOptions) {
-		o.ExpectedPhase = nil
-	}
-}
-
-// ToModifyOptions converts variadic options to ModifyOptions.
-func ToModifyOptions(opts ...ModifyOption) ModifyOptions {
-	phase := resource.PhaseRunning
-
-	options := ModifyOptions{
-		ExpectedPhase: &phase,
-	}
-
-	for _, opt := range opts {
-		opt(&options)
-	}
-
-	return options
+	return owned.WithExpectedPhaseAny()
 }

pkg/controller/runtime/internal/controllerstate/adapter.go

@@ -17,15 +17,16 @@ import (
 	"github.com/cosi-project/runtime/pkg/controller/runtime/internal/cache"
 	"github.com/cosi-project/runtime/pkg/resource"
 	"github.com/cosi-project/runtime/pkg/state"
+	"github.com/cosi-project/runtime/pkg/state/owned"
 )
 
 // StateAdapter implements filtered access to the resource state by controller inputs/outputs.
 //
 // If the read cache is enabled for a resource type, controller.Reader interface will be redirected to the cache.
 type StateAdapter struct {
-	State state.State
-	Cache *cache.ResourceCache
-	Name  string
+	OwnedState *owned.State
+	Cache      *cache.ResourceCache
+	Name       string
 
 	UpdateLimiter *rate.Limiter
 	Logger        *zap.Logger
@@ -120,7 +121,7 @@ func (adapter *StateAdapter) get(ctx context.Context, disableCache bool, resourc
 		adapter.Logger.Warn("get uncached resource", zap.String("namespace", resourcePointer.Namespace()), zap.String("type", resourcePointer.Type()), zap.String("id", resourcePointer.ID()))
 	}
 
-	return adapter.State.Get(ctx, resourcePointer, opts...)
+	return adapter.OwnedState.Get(ctx, resourcePointer, opts...)
 }
 
 // List implements controller.Runtime interface.
@@ -147,7 +148,7 @@ func (adapter *StateAdapter) list(ctx context.Context, disableCache bool, resour
 		adapter.Logger.Warn("list uncached resource", zap.String("namespace", resourceKind.Namespace()), zap.String("type", resourceKind.Type()))
 	}
 
-	return adapter.State.List(ctx, resourceKind, opts...)
+	return adapter.OwnedState.List(ctx, resourceKind, opts...)
 }
 
 // ContextWithTeardown implements controller.Runtime interface.
@@ -164,7 +165,7 @@ func (adapter *StateAdapter) ContextWithTeardown(ctx context.Context, resourcePo
 		adapter.Logger.Warn("context with teardown on uncached resource", zap.String("namespace", resourcePointer.Namespace()), zap.String("type", resourcePointer.Type()))
 	}
 
-	return adapter.State.ContextWithTeardown(ctx, resourcePointer)
+	return adapter.OwnedState.ContextWithTeardown(ctx, resourcePointer)
 }
 
 // Create implements controller.Runtime interface.
@@ -178,7 +179,7 @@ func (adapter *StateAdapter) Create(ctx context.Context, r resource.Resource) er
 			r.Metadata().Namespace(), r.Metadata().Type(), adapter.Name, r.Metadata().ID())
 	}
 
-	return adapter.State.Create(ctx, r, state.WithCreateOwner(adapter.Name))
+	return adapter.OwnedState.Create(ctx, r)
 }
 
 // Update implements controller.Runtime interface.
@@ -192,7 +193,7 @@ func (adapter *StateAdapter) Update(ctx context.Context, newResource resource.Re
 			newResource.Metadata().Namespace(), newResource.Metadata().Type(), adapter.Name, newResource.Metadata().ID())
 	}
 
-	return adapter.State.Update(ctx, newResource, state.WithUpdateOwner(adapter.Name))
+	return adapter.OwnedState.Update(ctx, newResource)
 }
 
 // Modify implements controller.Runtime interface.
@@ -223,16 +224,7 @@ func (adapter *StateAdapter) modify(
 			emptyResource.Metadata().Namespace(), emptyResource.Metadata().Type(), adapter.Name, emptyResource.Metadata().ID())
 	}
 
-	updateOptions := []state.UpdateOption{state.WithUpdateOwner(adapter.Name)}
-
-	modifyOptions := controller.ToModifyOptions(options...)
-	if modifyOptions.ExpectedPhase != nil {
-		updateOptions = append(updateOptions, state.WithExpectedPhase(*modifyOptions.ExpectedPhase))
-	} else {
-		updateOptions = append(updateOptions, state.WithExpectedPhaseAny())
-	}
-
-	return adapter.State.ModifyWithResult(ctx, emptyResource, updateFunc, updateOptions...)
+	return adapter.OwnedState.ModifyWithResult(ctx, emptyResource, updateFunc, options...)
 }
 
 // AddFinalizer implements controller.Runtime interface.
@@ -245,7 +237,7 @@ func (adapter *StateAdapter) AddFinalizer(ctx context.Context, resourcePointer r
 		return err
 	}
 
-	return adapter.State.AddFinalizer(ctx, resourcePointer, fins...)
+	return adapter.OwnedState.AddFinalizer(ctx, resourcePointer, fins...)
 }
 
 // RemoveFinalizer implements controller.Runtime interface.
@@ -258,7 +250,7 @@ func (adapter *StateAdapter) RemoveFinalizer(ctx context.Context, resourcePointe
 		return err
 	}
 
-	err := adapter.State.RemoveFinalizer(ctx, resourcePointer, fins...)
+	err := adapter.OwnedState.RemoveFinalizer(ctx, resourcePointer, fins...)
 	if state.IsNotFoundError(err) {
 		err = nil
 	}
@@ -276,16 +268,7 @@ func (adapter *StateAdapter) Teardown(ctx context.Context, resourcePointer resou
 		return false, fmt.Errorf("resource %q/%q is not an output for controller %q, teardown attempted on %q", resourcePointer.Namespace(), resourcePointer.Type(), adapter.Name, resourcePointer.ID())
 	}
 
-	var opts []state.TeardownOption
-
-	opOpt := controller.ToDeleteOptions(opOpts...)
-	if opOpt.Owner != nil {
-		opts = append(opts, state.WithTeardownOwner(*opOpt.Owner))
-	} else {
-		opts = append(opts, state.WithTeardownOwner(adapter.Name))
-	}
-
-	return adapter.State.Teardown(ctx, resourcePointer, opts...)
+	return adapter.OwnedState.Teardown(ctx, resourcePointer, opOpts...)
 }
 
 // Destroy implements controller.Runtime interface.
@@ -298,14 +281,5 @@ func (adapter *StateAdapter) Destroy(ctx context.Context, resourcePointer resour
 		return fmt.Errorf("resource %q/%q is not an output for controller %q, destroy attempted on %q", resourcePointer.Namespace(), resourcePointer.Type(), adapter.Name, resourcePointer.ID())
 	}
 
-	var opts []state.DestroyOption
-
-	opOpt := controller.ToDeleteOptions(opOpts...)
-	if opOpt.Owner != nil {
-		opts = append(opts, state.WithDestroyOwner(*opOpt.Owner))
-	} else {
-		opts = append(opts, state.WithDestroyOwner(adapter.Name))
-	}
-
-	return adapter.State.Destroy(ctx, resourcePointer, opts...)
+	return adapter.OwnedState.Destroy(ctx, resourcePointer, opOpts...)
 }

pkg/controller/runtime/internal/qruntime/qruntime.go

@@ -27,6 +27,7 @@ import (
 	"github.com/cosi-project/runtime/pkg/controller/runtime/metrics"
 	"github.com/cosi-project/runtime/pkg/logging"
 	"github.com/cosi-project/runtime/pkg/resource"
+	"github.com/cosi-project/runtime/pkg/state/owned"
 )
 
 type resourceNamespaceType struct {
@@ -105,7 +106,7 @@ func NewAdapter(
 
 	return &Adapter{
 		StateAdapter: controllerstate.StateAdapter{
-			State:               state,
+			OwnedState:          owned.New(state, name),
 			Cache:               adapterOptions.Cache,
 			Name:                name,
 			UpdateLimiter:       rate.NewLimiter(adapterOptions.RuntimeOptions.ChangeRateLimit, adapterOptions.RuntimeOptions.ChangeBurst),

pkg/controller/runtime/internal/rruntime/rruntime.go

@@ -22,6 +22,7 @@ import (
 	"github.com/cosi-project/runtime/pkg/controller/runtime/metrics"
 	"github.com/cosi-project/runtime/pkg/controller/runtime/options"
 	"github.com/cosi-project/runtime/pkg/resource"
+	"github.com/cosi-project/runtime/pkg/state/owned"
 )
 
 // Adapter connects common controller-runtime and rruntime controller.
@@ -64,7 +65,7 @@ func NewAdapter(
 	adapter := &Adapter{
 		StateAdapter: controllerstate.StateAdapter{
 			Name:                ctrl.Name(),
-			State:               state,
+			OwnedState:          owned.New(state, ctrl.Name()),
 			Cache:               adapterOptions.Cache,
 			Outputs:             slices.Clone(ctrl.Outputs()),
 			UpdateLimiter:       rate.NewLimiter(adapterOptions.RuntimeOptions.ChangeRateLimit, adapterOptions.RuntimeOptions.ChangeBurst),

pkg/state/owned/owned.go

@@ -0,0 +1,107 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Package owned contains the wrapping state for enforcing ownership.
+package owned
+
+import (
+	"context"
+
+	"github.com/cosi-project/runtime/pkg/resource"
+	"github.com/cosi-project/runtime/pkg/state"
+)
+
+// Reader provides read-only access to the state.
+//
+// Is is identical to the [state.State] interface, and it does not
+// provide any additional methods.
+type Reader interface {
+	Get(context.Context, resource.Pointer, ...state.GetOption) (resource.Resource, error)
+	List(context.Context, resource.Kind, ...state.ListOption) (resource.List, error)
+	ContextWithTeardown(context.Context, resource.Pointer) (context.Context, error)
+}
+
+// Writer provides write access to the state.
+//
+// Write methods enforce that the resources are owned by the designated owner.
+type Writer interface {
+	Create(context.Context, resource.Resource) error
+	Update(context.Context, resource.Resource) error
+	Modify(context.Context, resource.Resource, func(resource.Resource) error, ...ModifyOption) error
+	ModifyWithResult(context.Context, resource.Resource, func(resource.Resource) error, ...ModifyOption) (resource.Resource, error)
+	Teardown(context.Context, resource.Pointer, ...DeleteOption) (bool, error)
+	Destroy(context.Context, resource.Pointer, ...DeleteOption) error
+
+	AddFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error
+	RemoveFinalizer(context.Context, resource.Pointer, ...resource.Finalizer) error
+}
+
+// ReaderWriter combines Reader and Writer interfaces.
+type ReaderWriter interface {
+	Reader
+	Writer
+}
+
+// DeleteOption for operation Teardown/Destroy.
+type DeleteOption func(*DeleteOptions)
+
+// DeleteOptions for operation Teardown/Destroy.
+type DeleteOptions struct {
+	Owner *string
+}
+
+// WithOwner allows to specify owner of the resource.
+func WithOwner(owner string) DeleteOption {
+	return func(o *DeleteOptions) {
+		o.Owner = &owner
+	}
+}
+
+// ToDeleteOptions converts variadic options to DeleteOptions.
+func ToDeleteOptions(opts ...DeleteOption) DeleteOptions {
+	var options DeleteOptions
+
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	return options
+}
+
+// ModifyOption for operation Modify.
+type ModifyOption func(*ModifyOptions)
+
+// ModifyOptions for operation Modify.
+type ModifyOptions struct {
+	ExpectedPhase *resource.Phase
+}
+
+// WithExpectedPhase allows to specify expected phase of the resource.
+func WithExpectedPhase(phase resource.Phase) ModifyOption {
+	return func(o *ModifyOptions) {
+		o.ExpectedPhase = &phase
+	}
+}
+
+// WithExpectedPhaseAny allows to specify any phase of the resource.
+func WithExpectedPhaseAny() ModifyOption {
+	return func(o *ModifyOptions) {
+		o.ExpectedPhase = nil
+	}
+}
+
+// ToModifyOptions converts variadic options to ModifyOptions.
+func ToModifyOptions(opts ...ModifyOption) ModifyOptions {
+	phase := resource.PhaseRunning
+
+	options := ModifyOptions{
+		ExpectedPhase: &phase,
+	}
+
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	return options
+}