crossplane
/
crossplane-runtime
mirror of https://github.com/crossplane/crossplane-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

class to nonportable class 

Signed-off-by: hasheddan <georgedanielmangum@gmail.com>
This commit is contained in:
hasheddan 2019-09-11 22:59:59 -05:00
parent 161ab47fb3
commit 06cc35d1e3
13 changed files with 123 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
apis/core/v1alpha1/resource.go
View File

@ -46,7 +46,7 @@ type ResourceClaimSpec struct {
// TODO(negz): Make the below references immutable once set? Doing so means
// we don't have to track what provisioner was used to create a resource.
// PortableClassReference must reference a portable class by name
// PortableClassReference is a reference to a portable class by name.
PortableClassReference *corev1.LocalObjectReference `json:"classRef,omitempty"`
ResourceReference *corev1.ObjectReference `json:"resourceRef,omitempty"`
}
@ -66,17 +66,17 @@ type ResourceSpec struct {
ClaimReference *corev1.ObjectReference `json:"claimRef,omitempty"`
// NonPortableClassReference must reference a non-portable class by GVK
// NonPortableClassReference is a reference to a non-portable class.
NonPortableClassReference *corev1.ObjectReference `json:"classRef,omitempty"`
ProviderReference *corev1.ObjectReference `json:"providerRef"`
ReclaimPolicy ReclaimPolicy `json:"reclaimPolicy,omitempty"`
}
// ResourceClassSpecTemplate contains standard fields that all resource classes should
// include in their spec template. ResourceClassSpecTemplate should typically be embedded in a
// resource class specific struct.
type ResourceClassSpecTemplate struct {
// NonPortableClassSpecTemplate contains standard fields that all non-portable classes should
// include in their spec template. NonPortableClassSpecTemplate should typically be embedded in a
// non-portable class specific struct.
type NonPortableClassSpecTemplate struct {
ProviderReference *corev1.ObjectReference `json:"providerRef"`
ReclaimPolicy ReclaimPolicy `json:"reclaimPolicy,omitempty"`
@ -94,7 +94,7 @@ type ResourceStatus struct {
// should typically be embedded in a specific portable class.
type PortableClass struct {
// NonPortableClassReference must reference a non-portable class by GVK
// NonPortableClassReference is a reference to a non-portable class.
NonPortableClassReference *corev1.ObjectReference `json:"classRef,omitempty"`
}

40
apis/core/v1alpha1/zz_generated.deepcopy.go
View File

@ -77,6 +77,26 @@ func (in *ConditionedStatus) DeepCopy() *ConditionedStatus {
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NonPortableClassSpecTemplate) DeepCopyInto(out *NonPortableClassSpecTemplate) {
*out = *in
if in.ProviderReference != nil {
in, out := &in.ProviderReference, &out.ProviderReference
*out = new(v1.ObjectReference)
**out = **in
}
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NonPortableClassSpecTemplate.
func (in *NonPortableClassSpecTemplate) DeepCopy() *NonPortableClassSpecTemplate {
if in == nil {
return nil
}
out := new(NonPortableClassSpecTemplate)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PortableClass) DeepCopyInto(out *PortableClass) {
*out = *in
@ -140,26 +160,6 @@ func (in *ResourceClaimStatus) DeepCopy() *ResourceClaimStatus {
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceClassSpecTemplate) DeepCopyInto(out *ResourceClassSpecTemplate) {
*out = *in
if in.ProviderReference != nil {
in, out := &in.ProviderReference, &out.ProviderReference
*out = new(v1.ObjectReference)
**out = **in
}
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceClassSpecTemplate.
func (in *ResourceClassSpecTemplate) DeepCopy() *ResourceClassSpecTemplate {
if in == nil {
return nil
}
out := new(ResourceClassSpecTemplate)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceSpec) DeepCopyInto(out *ResourceSpec) {
*out = *in

2
pkg/resource/api.go
View File

@ -57,7 +57,7 @@ func NewAPIManagedCreator(c client.Client, t runtime.ObjectTyper) *APIManagedCre
}
// Create the supplied resource using the supplied class and claim.
func (a *APIManagedCreator) Create(ctx context.Context, cm Claim, cs Class, mg Managed) error {
func (a *APIManagedCreator) Create(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error {
cmr := meta.ReferenceTo(cm, MustGetKind(cm, a.typer))
csr := meta.ReferenceTo(cs, MustGetKind(cs, a.typer))
mgr := meta.ReferenceTo(mg, MustGetKind(mg, a.typer))

18
pkg/resource/api_test.go
View File

@ -52,7 +52,7 @@ func TestCreate(t *testing.T) {
type args struct {
ctx context.Context
cm Claim
cs Class
cs NonPortableClass
mg Managed
}
@ -71,12 +71,12 @@ func TestCreate(t *testing.T) {
client: &test.MockClient{
MockCreate: test.NewMockCreateFn(errBoom),
},
typer: MockSchemeWith(&MockClaim{}, &MockClass{}, &MockManaged{}),
typer: MockSchemeWith(&MockClaim{}, &MockNonPortableClass{}, &MockManaged{}),
},
args: args{
ctx: context.Background(),
cm: &MockClaim{},
cs: &MockClass{},
cs: &MockNonPortableClass{},
mg: &MockManaged{},
},
want: errors.Wrap(errBoom, errCreateManaged),
@ -87,12 +87,12 @@ func TestCreate(t *testing.T) {
MockCreate: test.NewMockCreateFn(nil),
MockUpdate: test.NewMockUpdateFn(errBoom),
},
typer: MockSchemeWith(&MockClaim{}, &MockClass{}, &MockManaged{}),
typer: MockSchemeWith(&MockClaim{}, &MockNonPortableClass{}, &MockManaged{}),
},
args: args{
ctx: context.Background(),
cm: &MockClaim{},
cs: &MockClass{},
cs: &MockNonPortableClass{},
mg: &MockManaged{},
},
want: errors.Wrap(errBoom, errUpdateClaim),
@ -110,8 +110,8 @@ func TestCreate(t *testing.T) {
})
want.SetNonPortableClassReference(&corev1.ObjectReference{
Name: csname,
APIVersion: MockGVK(&MockClass{}).GroupVersion().String(),
Kind: MockGVK(&MockClass{}).Kind,
APIVersion: MockGVK(&MockNonPortableClass{}).GroupVersion().String(),
Kind: MockGVK(&MockNonPortableClass{}).Kind,
})
if diff := cmp.Diff(want, got, test.EquateConditions()); diff != "" {
t.Errorf("-want, +got:\n%s", diff)
@ -133,12 +133,12 @@ func TestCreate(t *testing.T) {
return nil
}),
},
typer: MockSchemeWith(&MockClaim{}, &MockClass{}, &MockManaged{}),
typer: MockSchemeWith(&MockClaim{}, &MockNonPortableClass{}, &MockManaged{}),
},
args: args{
ctx: context.Background(),
cm: &MockClaim{ObjectMeta: metav1.ObjectMeta{Name: cmname}},
cs: &MockClass{ObjectMeta: metav1.ObjectMeta{Name: csname}},
cs: &MockNonPortableClass{ObjectMeta: metav1.ObjectMeta{Name: csname}},
mg: &MockManaged{ObjectMeta: metav1.ObjectMeta{Name: mgname}},
},
want: nil,

40
pkg/resource/claim_reconciler.go
View File

@ -69,15 +69,15 @@ type ManagedKind schema.GroupVersionKind
// A ManagedConfigurator configures a resource, typically by converting it to
// a known type and populating its spec.
type ManagedConfigurator interface {
Configure(ctx context.Context, cm Claim, cs Class, mg Managed) error
Configure(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error
}
// A ManagedConfiguratorFn is a function that sastisfies the
// ManagedConfigurator interface.
type ManagedConfiguratorFn func(ctx context.Context, cm Claim, cs Class, mg Managed) error
type ManagedConfiguratorFn func(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error
// Configure the supplied resource using the supplied claim and class.
func (fn ManagedConfiguratorFn) Configure(ctx context.Context, cm Claim, cs Class, mg Managed) error {
func (fn ManagedConfiguratorFn) Configure(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error {
return fn(ctx, cm, cs, mg)
}
@ -86,14 +86,14 @@ func (fn ManagedConfiguratorFn) Configure(ctx context.Context, cm Claim, cs Clas
// responsible for final modifications to the claim and resource, for example
// ensuring resource, class, claim, and owner references are set.
type ManagedCreator interface {
Create(ctx context.Context, cm Claim, cs Class, mg Managed) error
Create(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error
}
// A ManagedCreatorFn is a function that sastisfies the ManagedCreator interface.
type ManagedCreatorFn func(ctx context.Context, cm Claim, cs Class, mg Managed) error
type ManagedCreatorFn func(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error
// Create the supplied resource.
func (fn ManagedCreatorFn) Create(ctx context.Context, cm Claim, cs Class, mg Managed) error {
func (fn ManagedCreatorFn) Create(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error {
return fn(ctx, cm, cs, mg)
}
@ -160,11 +160,11 @@ func (fn ClaimFinalizerFn) Finalize(ctx context.Context, cm Claim) error {
// type of resource class provisioner. Each controller must watch its subset of
// resource claims and any managed resources they control.
type ClaimReconciler struct {
client client.Client
newClaim func() Claim
newClass func() Class
newPortableClass func() PortableClass
newManaged func() Managed
client client.Client
newClaim func() Claim
newNonPortableClass func() NonPortableClass
newPortableClass func() PortableClass
newManaged func() Managed
// The below structs embed the set of interfaces used to implement the
// resource claim reconciler. We do this primarily for readability, so that
@ -259,7 +259,7 @@ func WithClaimFinalizer(f ClaimFinalizer) ClaimReconcilerOption {
// one or more ManagedConfigurators to configure their managed resources.
func NewClaimReconciler(m manager.Manager, of ClaimKind, using ClassKinds, with ManagedKind, o ...ClaimReconcilerOption) *ClaimReconciler {
nc := func() Claim { return MustCreateObject(schema.GroupVersionKind(of), m.GetScheme()).(Claim) }
ns := func() Class { return MustCreateObject(using.NonPortable, m.GetScheme()).(Class) }
ns := func() NonPortableClass { return MustCreateObject(using.NonPortable, m.GetScheme()).(NonPortableClass) }
np := func() PortableClass { return MustCreateObject(using.Portable, m.GetScheme()).(PortableClass) }
nr := func() Managed { return MustCreateObject(schema.GroupVersionKind(with), m.GetScheme()).(Managed) }
@ -268,13 +268,13 @@ func NewClaimReconciler(m manager.Manager, of ClaimKind, using ClassKinds, with
_, _, _, _ = nc(), ns(), np(), nr()
r := &ClaimReconciler{
client: m.GetClient(),
newClaim: nc,
newClass: ns,
newPortableClass: np,
newManaged: nr,
managed: defaultCRManaged(m),
claim: defaultCRClaim(m),
client: m.GetClient(),
newClaim: nc,
newNonPortableClass: ns,
newPortableClass: np,
newManaged: nr,
managed: defaultCRManaged(m),
claim: defaultCRClaim(m),
}
for _, ro := range o {
@ -354,7 +354,7 @@ func (r *ClaimReconciler) Reconcile(req reconcile.Request) (reconcile.Result, er
return reconcile.Result{RequeueAfter: aShortWait}, errors.Wrap(r.client.Status().Update(ctx, claim), errUpdateClaimStatus)
}
class := r.newClass()
class := r.newNonPortableClass()
// Class reference should always be set by the time we get this far; we
// set it on last reconciliation.
if err := r.client.Get(ctx, meta.NamespacedNameOf(portable.GetNonPortableClassReference()), class); err != nil {

72
pkg/resource/claim_reconciler_test.go
View File

@ -85,10 +85,10 @@ func TestClaimReconciler(t *testing.T) {
args: args{
m: &MockManager{
c: &test.MockClient{MockGet: test.NewMockGetFn(errBoom)},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{err: errors.Wrap(errBoom, errGetClaim)},
@ -120,10 +120,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{RequeueAfter: aShortWait}},
@ -153,10 +153,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedFinalizer(ManagedFinalizerFn(func(_ context.Context, _ Managed) error { return errBoom })),
@ -189,10 +189,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedFinalizer(ManagedFinalizerFn(func(_ context.Context, _ Managed) error { return nil })),
@ -226,10 +226,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedFinalizer(ManagedFinalizerFn(func(_ context.Context, _ Managed) error { return nil })),
@ -263,10 +263,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedFinalizer(ManagedFinalizerFn(func(_ context.Context, _ Managed) error { return nil })),
@ -302,10 +302,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{RequeueAfter: aShortWait}},
@ -326,7 +326,7 @@ func TestClaimReconciler(t *testing.T) {
pc.SetNonPortableClassReference(&corev1.ObjectReference{})
*o = *pc
return nil
case *MockClass:
case *MockNonPortableClass:
return errBoom
default:
return errUnexpected
@ -342,10 +342,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{RequeueAfter: aShortWait}},
@ -366,7 +366,7 @@ func TestClaimReconciler(t *testing.T) {
pc.SetNonPortableClassReference(&corev1.ObjectReference{})
*o = *pc
return nil
case *MockClass:
case *MockNonPortableClass:
return nil
default:
return errUnexpected
@ -382,13 +382,13 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{WithManagedConfigurators(ManagedConfiguratorFn(
func(_ context.Context, _ Claim, _ Class, _ Managed) error { return errBoom },
func(_ context.Context, _ Claim, _ NonPortableClass, _ Managed) error { return errBoom },
))},
},
want: want{result: reconcile.Result{RequeueAfter: aShortWait}},
@ -409,7 +409,7 @@ func TestClaimReconciler(t *testing.T) {
pc.SetNonPortableClassReference(&corev1.ObjectReference{})
*o = *pc
return nil
case *MockClass:
case *MockNonPortableClass:
return nil
default:
return errUnexpected
@ -425,17 +425,17 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedConfigurators(ManagedConfiguratorFn(
func(_ context.Context, _ Claim, _ Class, _ Managed) error { return nil },
func(_ context.Context, _ Claim, _ NonPortableClass, _ Managed) error { return nil },
)),
WithManagedCreator(ManagedCreatorFn(
func(_ context.Context, _ Claim, _ Class, _ Managed) error { return errBoom },
func(_ context.Context, _ Claim, _ NonPortableClass, _ Managed) error { return errBoom },
)),
},
},
@ -474,10 +474,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{Requeue: false}},
@ -513,10 +513,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{Requeue: false}},
@ -552,10 +552,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedConnectionPropagator(ManagedConnectionPropagatorFn(
@ -596,10 +596,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
o: []ClaimReconcilerOption{
WithManagedConnectionPropagator(ManagedConnectionPropagatorFn(
@ -643,10 +643,10 @@ func TestClaimReconciler(t *testing.T) {
return nil
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}, &MockManaged{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}, &MockManaged{}),
},
of: ClaimKind(MockGVK(&MockClaim{})),
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})},
use: ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})},
with: ManagedKind(MockGVK(&MockManaged{})),
},
want: want{result: reconcile.Result{Requeue: false}},

4
pkg/resource/configurator.go
View File

@ -33,7 +33,7 @@ type ConfiguratorChain []ManagedConfigurator
// Configure calls each ManagedConfigurator serially. It returns the first
// error it encounters, if any.
func (cc ConfiguratorChain) Configure(ctx context.Context, cm Claim, cs Class, mg Managed) error {
func (cc ConfiguratorChain) Configure(ctx context.Context, cm Claim, cs NonPortableClass, mg Managed) error {
for _, c := range cc {
if err := c.Configure(ctx, cm, cs, mg); err != nil {
return err
@ -54,7 +54,7 @@ func NewObjectMetaConfigurator(t runtime.ObjectTyper) *ObjectMetaConfigurator {
}
// Configure the supplied Managed resource's object metadata.
func (c *ObjectMetaConfigurator) Configure(_ context.Context, cm Claim, cs Class, mg Managed) error {
func (c *ObjectMetaConfigurator) Configure(_ context.Context, cm Claim, cs NonPortableClass, mg Managed) error {
mg.SetNamespace(cs.GetNamespace())
mg.SetName(fmt.Sprintf("%s-%s", kindish(cm), cm.GetUID()))

16
pkg/resource/configurator_test.go
View File

@ -42,7 +42,7 @@ func TestConfiguratorChain(t *testing.T) {
type args struct {
ctx context.Context
cm Claim
cs Class
cs NonPortableClass
mg Managed
}
@ -56,35 +56,35 @@ func TestConfiguratorChain(t *testing.T) {
args: args{
ctx: context.Background(),
cm: &MockClaim{},
cs: &MockClass{},
cs: &MockNonPortableClass{},
mg: &MockManaged{},
},
want: nil,
},
"SuccessulConfigurator": {
cc: ConfiguratorChain{
ManagedConfiguratorFn(func(_ context.Context, _ Claim, _ Class, _ Managed) error {
ManagedConfiguratorFn(func(_ context.Context, _ Claim, _ NonPortableClass, _ Managed) error {
return nil
}),
},
args: args{
ctx: context.Background(),
cm: &MockClaim{},
cs: &MockClass{},
cs: &MockNonPortableClass{},
mg: &MockManaged{},
},
want: nil,
},
"ConfiguratorReturnsError": {
cc: ConfiguratorChain{
ManagedConfiguratorFn(func(_ context.Context, _ Claim, _ Class, _ Managed) error {
ManagedConfiguratorFn(func(_ context.Context, _ Claim, _ NonPortableClass, _ Managed) error {
return errBoom
}),
},
args: args{
ctx: context.Background(),
cm: &MockClaim{},
cs: &MockClass{},
cs: &MockNonPortableClass{},
mg: &MockManaged{},
},
want: errBoom,
@ -108,7 +108,7 @@ func TestConfigureObjectMeta(t *testing.T) {
type args struct {
ctx context.Context
cm Claim
cs Class
cs NonPortableClass
mg Managed
}
@ -127,7 +127,7 @@ func TestConfigureObjectMeta(t *testing.T) {
args: args{
ctx: context.Background(),
cm: &MockClaim{ObjectMeta: metav1.ObjectMeta{UID: uid}},
cs: &MockClass{ObjectMeta: metav1.ObjectMeta{Namespace: ns}},
cs: &MockNonPortableClass{ObjectMeta: metav1.ObjectMeta{Namespace: ns}},
mg: &MockManaged{},
},
want: want{

2
pkg/resource/defaultclass_test.go
View File

@ -17,7 +17,6 @@ limitations under the License.
package resource
import (
"fmt"
"reflect"
"testing"
@ -253,7 +252,6 @@ func TestDefaultClassReconcile(t *testing.T) {
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
r := NewDefaultClassReconciler(tc.args.m, tc.args.of, tc.args.by, tc.args.o...)
fmt.Println(name)
got, err := r.Reconcile(reconcile.Request{})
if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" {

10
pkg/resource/interfaces.go
View File

@ -74,8 +74,8 @@ type Reclaimer interface {
GetReclaimPolicy() v1alpha1.ReclaimPolicy
}
// A PortableClassItemer may contain a list of portable classes.
type PortableClassItemer interface {
// A PortableClassLister may contain a list of portable classes.
type PortableClassLister interface {
SetPortableClassItems(i []PortableClass)
GetPortableClassItems() []PortableClass
}
@ -95,9 +95,9 @@ type Claim interface {
Bindable
}
// A Class is a Kubernetes object representing configuration
// A NonPortableClass is a Kubernetes object representing configuration
// specifications for a manged resource.
type Class interface {
type NonPortableClass interface {
runtime.Object
metav1.Object
@ -134,5 +134,5 @@ type PortableClassList interface {
runtime.Object
metav1.ListInterface
PortableClassItemer
PortableClassLister
}

12
pkg/resource/interfaces_test.go
View File

@ -75,10 +75,10 @@ type MockReclaimer struct{ Policy v1alpha1.ReclaimPolicy }
func (m *MockReclaimer) SetReclaimPolicy(p v1alpha1.ReclaimPolicy) { m.Policy = p }
func (m *MockReclaimer) GetReclaimPolicy() v1alpha1.ReclaimPolicy { return m.Policy }
type MockPortableClassItemer struct{ Items []PortableClass }
type MockPortableClassLister struct{ Items []PortableClass }
func (m *MockPortableClassItemer) SetPortableClassItems(i []PortableClass) { m.Items = i }
func (m *MockPortableClassItemer) GetPortableClassItems() []PortableClass { return m.Items }
func (m *MockPortableClassLister) SetPortableClassItems(i []PortableClass) { m.Items = i }
func (m *MockPortableClassLister) GetPortableClassItems() []PortableClass { return m.Items }
var _ Claim = &MockClaim{}
@ -93,9 +93,9 @@ type MockClaim struct {
MockBindable
}
var _ Class = &MockClass{}
var _ NonPortableClass = &MockNonPortableClass{}
type MockClass struct {
type MockNonPortableClass struct {
runtime.Object
metav1.ObjectMeta
@ -131,5 +131,5 @@ type MockPortableClassList struct {
runtime.Object
metav1.ListInterface
MockPortableClassItemer
MockPortableClassLister
}

4
pkg/resource/predicates.go
View File

@ -41,7 +41,7 @@ func NewPredicates(fn PredicateFn) predicate.Funcs {
}
// HasClassReferenceKinds accepts ResourceClaims that reference the correct kind of resourceclass
func HasClassReferenceKinds(c client.Client, scheme runtime.ObjectCreater, k ClassKinds) PredicateFn {
func HasClassReferenceKinds(c client.Client, oc runtime.ObjectCreater, k ClassKinds) PredicateFn {
return func(obj runtime.Object) bool {
claim, ok := obj.(Claim)
if !ok {
@ -56,7 +56,7 @@ func HasClassReferenceKinds(c client.Client, scheme runtime.ObjectCreater, k Cla
ctx, cancel := context.WithTimeout(context.Background(), claimReconcileTimeout)
defer cancel()
portable := MustCreateObject(k.Portable, scheme).(PortableClass)
portable := MustCreateObject(k.Portable, oc).(PortableClass)
p := types.NamespacedName{
Namespace: claim.GetNamespace(),
Name: pr.Name,

14
pkg/resource/predicates_test.go
View File

@ -51,7 +51,7 @@ func (r *mockManagedResourceReferencer) SetResourceReference(_ *corev1.ObjectRef
func TestHasClassReferenceKinds(t *testing.T) {
errBoom := errors.New("boom")
errUnexpected := errors.New("unexpected object type")
ck := ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockClass{})}
ck := ClassKinds{Portable: MockGVK(&MockPortableClass{}), NonPortable: MockGVK(&MockNonPortableClass{})}
mockClaimWithRef := MockClaim{}
mockClaimWithRef.SetPortableClassReference(&corev1.LocalObjectReference{Name: "cool-portable"})
@ -65,21 +65,21 @@ func TestHasClassReferenceKinds(t *testing.T) {
}{
"NotAClaim": {
c: &test.MockClient{},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}),
obj: &mockObject{},
kind: ck,
want: false,
},
"NoPortableClassReference": {
c: &test.MockClient{},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}),
obj: &MockClaim{},
kind: ck,
want: false,
},
"GetPortableClassError": {
c: &test.MockClient{MockGet: test.NewMockGetFn(errBoom)},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}),
obj: &mockClaimWithRef,
kind: ck,
want: false,
@ -98,7 +98,7 @@ func TestHasClassReferenceKinds(t *testing.T) {
}
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}),
obj: &mockClaimWithRef,
kind: ck,
want: false,
@ -109,7 +109,7 @@ func TestHasClassReferenceKinds(t *testing.T) {
switch o := o.(type) {
case *MockPortableClass:
pc := &MockPortableClass{}
version, kind := MockGVK(&MockClass{}).ToAPIVersionAndKind()
version, kind := MockGVK(&MockNonPortableClass{}).ToAPIVersionAndKind()
pc.SetNonPortableClassReference(&corev1.ObjectReference{
Kind: kind,
APIVersion: version,
@ -121,7 +121,7 @@ func TestHasClassReferenceKinds(t *testing.T) {
}
}),
},
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockClass{}),
s: MockSchemeWith(&MockClaim{}, &MockPortableClass{}, &MockNonPortableClass{}),
obj: &mockClaimWithRef,
kind: ck,
want: true,