zz_controller.go

/*
Copyright 2021 The Crossplane Authors.

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.
*/

// Code generated by ack-generate. DO NOT EDIT.

package dbcluster

import (
	"context"

	svcapi "github.com/aws/aws-sdk-go/service/rds"
	svcsdk "github.com/aws/aws-sdk-go/service/rds"
	svcsdkapi "github.com/aws/aws-sdk-go/service/rds/rdsiface"
	"github.com/google/go-cmp/cmp"
	"github.com/pkg/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"

	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
	"github.com/crossplane/crossplane-runtime/pkg/meta"
	"github.com/crossplane/crossplane-runtime/pkg/reconciler/managed"
	cpresource "github.com/crossplane/crossplane-runtime/pkg/resource"

	svcapitypes "github.com/crossplane/provider-aws/apis/rds/v1alpha1"
	awsclient "github.com/crossplane/provider-aws/pkg/clients"
)

const (
	errUnexpectedObject = "managed resource is not an DBCluster resource"

	errCreateSession = "cannot create a new session"
	errCreate        = "cannot create DBCluster in AWS"
	errUpdate        = "cannot update DBCluster in AWS"
	errDescribe      = "failed to describe DBCluster"
	errDelete        = "failed to delete DBCluster"
)

type connector struct {
	kube client.Client
	opts []option
}

func (c *connector) Connect(ctx context.Context, mg cpresource.Managed) (managed.ExternalClient, error) {
	cr, ok := mg.(*svcapitypes.DBCluster)
	if !ok {
		return nil, errors.New(errUnexpectedObject)
	}
	sess, err := awsclient.GetConfigV1(ctx, c.kube, mg, cr.Spec.ForProvider.Region)
	if err != nil {
		return nil, errors.Wrap(err, errCreateSession)
	}
	return newExternal(c.kube, svcapi.New(sess), c.opts), nil
}

func (e *external) Observe(ctx context.Context, mg cpresource.Managed) (managed.ExternalObservation, error) {
	cr, ok := mg.(*svcapitypes.DBCluster)
	if !ok {
		return managed.ExternalObservation{}, errors.New(errUnexpectedObject)
	}
	if meta.GetExternalName(cr) == "" {
		return managed.ExternalObservation{
			ResourceExists: false,
		}, nil
	}
	input := GenerateDescribeDBClustersInput(cr)
	if err := e.preObserve(ctx, cr, input); err != nil {
		return managed.ExternalObservation{}, errors.Wrap(err, "pre-observe failed")
	}
	resp, err := e.client.DescribeDBClustersWithContext(ctx, input)
	if err != nil {
		return managed.ExternalObservation{ResourceExists: false}, awsclient.Wrap(cpresource.Ignore(IsNotFound, err), errDescribe)
	}
	resp = e.filterList(cr, resp)
	if len(resp.DBClusters) == 0 {
		return managed.ExternalObservation{ResourceExists: false}, nil
	}
	currentSpec := cr.Spec.ForProvider.DeepCopy()
	if err := e.lateInitialize(&cr.Spec.ForProvider, resp); err != nil {
		return managed.ExternalObservation{}, errors.Wrap(err, "late-init failed")
	}
	GenerateDBCluster(resp).Status.AtProvider.DeepCopyInto(&cr.Status.AtProvider)

	upToDate, err := e.isUpToDate(cr, resp)
	if err != nil {
		return managed.ExternalObservation{}, errors.Wrap(err, "isUpToDate check failed")
	}
	return e.postObserve(ctx, cr, resp, managed.ExternalObservation{
		ResourceExists:          true,
		ResourceUpToDate:        upToDate,
		ResourceLateInitialized: !cmp.Equal(&cr.Spec.ForProvider, currentSpec),
	}, nil)
}

func (e *external) Create(ctx context.Context, mg cpresource.Managed) (managed.ExternalCreation, error) {
	cr, ok := mg.(*svcapitypes.DBCluster)
	if !ok {
		return managed.ExternalCreation{}, errors.New(errUnexpectedObject)
	}
	cr.Status.SetConditions(xpv1.Creating())
	input := GenerateCreateDBClusterInput(cr)
	if err := e.preCreate(ctx, cr, input); err != nil {
		return managed.ExternalCreation{}, errors.Wrap(err, "pre-create failed")
	}
	resp, err := e.client.CreateDBClusterWithContext(ctx, input)
	if err != nil {
		return managed.ExternalCreation{}, awsclient.Wrap(err, errCreate)
	}

	if resp.DBCluster.ActivityStreamKinesisStreamName != nil {
		cr.Status.AtProvider.ActivityStreamKinesisStreamName = resp.DBCluster.ActivityStreamKinesisStreamName
	} else {
		cr.Status.AtProvider.ActivityStreamKinesisStreamName = nil
	}
	if resp.DBCluster.ActivityStreamKmsKeyId != nil {
		cr.Status.AtProvider.ActivityStreamKMSKeyID = resp.DBCluster.ActivityStreamKmsKeyId
	} else {
		cr.Status.AtProvider.ActivityStreamKMSKeyID = nil
	}
	if resp.DBCluster.ActivityStreamMode != nil {
		cr.Status.AtProvider.ActivityStreamMode = resp.DBCluster.ActivityStreamMode
	} else {
		cr.Status.AtProvider.ActivityStreamMode = nil
	}
	if resp.DBCluster.ActivityStreamStatus != nil {
		cr.Status.AtProvider.ActivityStreamStatus = resp.DBCluster.ActivityStreamStatus
	} else {
		cr.Status.AtProvider.ActivityStreamStatus = nil
	}
	if resp.DBCluster.AllocatedStorage != nil {
		cr.Status.AtProvider.AllocatedStorage = resp.DBCluster.AllocatedStorage
	} else {
		cr.Status.AtProvider.AllocatedStorage = nil
	}
	if resp.DBCluster.AssociatedRoles != nil {
		f5 := []*svcapitypes.DBClusterRole{}
		for _, f5iter := range resp.DBCluster.AssociatedRoles {
			f5elem := &svcapitypes.DBClusterRole{}
			if f5iter.FeatureName != nil {
				f5elem.FeatureName = f5iter.FeatureName
			}
			if f5iter.RoleArn != nil {
				f5elem.RoleARN = f5iter.RoleArn
			}
			if f5iter.Status != nil {
				f5elem.Status = f5iter.Status
			}
			f5 = append(f5, f5elem)
		}
		cr.Status.AtProvider.AssociatedRoles = f5
	} else {
		cr.Status.AtProvider.AssociatedRoles = nil
	}
	if resp.DBCluster.AutomaticRestartTime != nil {
		cr.Status.AtProvider.AutomaticRestartTime = &metav1.Time{*resp.DBCluster.AutomaticRestartTime}
	} else {
		cr.Status.AtProvider.AutomaticRestartTime = nil
	}
	if resp.DBCluster.AvailabilityZones != nil {
		f7 := []*string{}
		for _, f7iter := range resp.DBCluster.AvailabilityZones {
			var f7elem string
			f7elem = *f7iter
			f7 = append(f7, &f7elem)
		}
		cr.Spec.ForProvider.AvailabilityZones = f7
	} else {
		cr.Spec.ForProvider.AvailabilityZones = nil
	}
	if resp.DBCluster.BacktrackConsumedChangeRecords != nil {
		cr.Status.AtProvider.BacktrackConsumedChangeRecords = resp.DBCluster.BacktrackConsumedChangeRecords
	} else {
		cr.Status.AtProvider.BacktrackConsumedChangeRecords = nil
	}
	if resp.DBCluster.BacktrackWindow != nil {
		cr.Spec.ForProvider.BacktrackWindow = resp.DBCluster.BacktrackWindow
	} else {
		cr.Spec.ForProvider.BacktrackWindow = nil
	}
	if resp.DBCluster.BackupRetentionPeriod != nil {
		cr.Spec.ForProvider.BackupRetentionPeriod = resp.DBCluster.BackupRetentionPeriod
	} else {
		cr.Spec.ForProvider.BackupRetentionPeriod = nil
	}
	if resp.DBCluster.Capacity != nil {
		cr.Status.AtProvider.Capacity = resp.DBCluster.Capacity
	} else {
		cr.Status.AtProvider.Capacity = nil
	}
	if resp.DBCluster.CharacterSetName != nil {
		cr.Spec.ForProvider.CharacterSetName = resp.DBCluster.CharacterSetName
	} else {
		cr.Spec.ForProvider.CharacterSetName = nil
	}
	if resp.DBCluster.CloneGroupId != nil {
		cr.Status.AtProvider.CloneGroupID = resp.DBCluster.CloneGroupId
	} else {
		cr.Status.AtProvider.CloneGroupID = nil
	}
	if resp.DBCluster.ClusterCreateTime != nil {
		cr.Status.AtProvider.ClusterCreateTime = &metav1.Time{*resp.DBCluster.ClusterCreateTime}
	} else {
		cr.Status.AtProvider.ClusterCreateTime = nil
	}
	if resp.DBCluster.CopyTagsToSnapshot != nil {
		cr.Spec.ForProvider.CopyTagsToSnapshot = resp.DBCluster.CopyTagsToSnapshot
	} else {
		cr.Spec.ForProvider.CopyTagsToSnapshot = nil
	}
	if resp.DBCluster.CrossAccountClone != nil {
		cr.Status.AtProvider.CrossAccountClone = resp.DBCluster.CrossAccountClone
	} else {
		cr.Status.AtProvider.CrossAccountClone = nil
	}
	if resp.DBCluster.CustomEndpoints != nil {
		f17 := []*string{}
		for _, f17iter := range resp.DBCluster.CustomEndpoints {
			var f17elem string
			f17elem = *f17iter
			f17 = append(f17, &f17elem)
		}
		cr.Status.AtProvider.CustomEndpoints = f17
	} else {
		cr.Status.AtProvider.CustomEndpoints = nil
	}
	if resp.DBCluster.DBClusterArn != nil {
		cr.Status.AtProvider.DBClusterARN = resp.DBCluster.DBClusterArn
	} else {
		cr.Status.AtProvider.DBClusterARN = nil
	}
	if resp.DBCluster.DBClusterIdentifier != nil {
		cr.Status.AtProvider.DBClusterIdentifier = resp.DBCluster.DBClusterIdentifier
	} else {
		cr.Status.AtProvider.DBClusterIdentifier = nil
	}
	if resp.DBCluster.DBClusterMembers != nil {
		f20 := []*svcapitypes.DBClusterMember{}
		for _, f20iter := range resp.DBCluster.DBClusterMembers {
			f20elem := &svcapitypes.DBClusterMember{}
			if f20iter.DBClusterParameterGroupStatus != nil {
				f20elem.DBClusterParameterGroupStatus = f20iter.DBClusterParameterGroupStatus
			}
			if f20iter.DBInstanceIdentifier != nil {
				f20elem.DBInstanceIdentifier = f20iter.DBInstanceIdentifier
			}
			if f20iter.IsClusterWriter != nil {
				f20elem.IsClusterWriter = f20iter.IsClusterWriter
			}
			if f20iter.PromotionTier != nil {
				f20elem.PromotionTier = f20iter.PromotionTier
			}
			f20 = append(f20, f20elem)
		}
		cr.Status.AtProvider.DBClusterMembers = f20
	} else {
		cr.Status.AtProvider.DBClusterMembers = nil
	}
	if resp.DBCluster.DBClusterOptionGroupMemberships != nil {
		f21 := []*svcapitypes.DBClusterOptionGroupStatus{}
		for _, f21iter := range resp.DBCluster.DBClusterOptionGroupMemberships {
			f21elem := &svcapitypes.DBClusterOptionGroupStatus{}
			if f21iter.DBClusterOptionGroupName != nil {
				f21elem.DBClusterOptionGroupName = f21iter.DBClusterOptionGroupName
			}
			if f21iter.Status != nil {
				f21elem.Status = f21iter.Status
			}
			f21 = append(f21, f21elem)
		}
		cr.Status.AtProvider.DBClusterOptionGroupMemberships = f21
	} else {
		cr.Status.AtProvider.DBClusterOptionGroupMemberships = nil
	}
	if resp.DBCluster.DBClusterParameterGroup != nil {
		cr.Status.AtProvider.DBClusterParameterGroup = resp.DBCluster.DBClusterParameterGroup
	} else {
		cr.Status.AtProvider.DBClusterParameterGroup = nil
	}
	if resp.DBCluster.DBSubnetGroup != nil {
		cr.Status.AtProvider.DBSubnetGroup = resp.DBCluster.DBSubnetGroup
	} else {
		cr.Status.AtProvider.DBSubnetGroup = nil
	}
	if resp.DBCluster.DatabaseName != nil {
		cr.Spec.ForProvider.DatabaseName = resp.DBCluster.DatabaseName
	} else {
		cr.Spec.ForProvider.DatabaseName = nil
	}
	if resp.DBCluster.DbClusterResourceId != nil {
		cr.Status.AtProvider.DBClusterResourceID = resp.DBCluster.DbClusterResourceId
	} else {
		cr.Status.AtProvider.DBClusterResourceID = nil
	}
	if resp.DBCluster.DeletionProtection != nil {
		cr.Spec.ForProvider.DeletionProtection = resp.DBCluster.DeletionProtection
	} else {
		cr.Spec.ForProvider.DeletionProtection = nil
	}
	if resp.DBCluster.DomainMemberships != nil {
		f27 := []*svcapitypes.DomainMembership{}
		for _, f27iter := range resp.DBCluster.DomainMemberships {
			f27elem := &svcapitypes.DomainMembership{}
			if f27iter.Domain != nil {
				f27elem.Domain = f27iter.Domain
			}
			if f27iter.FQDN != nil {
				f27elem.FQDN = f27iter.FQDN
			}
			if f27iter.IAMRoleName != nil {
				f27elem.IAMRoleName = f27iter.IAMRoleName
			}
			if f27iter.Status != nil {
				f27elem.Status = f27iter.Status
			}
			f27 = append(f27, f27elem)
		}
		cr.Status.AtProvider.DomainMemberships = f27
	} else {
		cr.Status.AtProvider.DomainMemberships = nil
	}
	if resp.DBCluster.EarliestBacktrackTime != nil {
		cr.Status.AtProvider.EarliestBacktrackTime = &metav1.Time{*resp.DBCluster.EarliestBacktrackTime}
	} else {
		cr.Status.AtProvider.EarliestBacktrackTime = nil
	}
	if resp.DBCluster.EarliestRestorableTime != nil {
		cr.Status.AtProvider.EarliestRestorableTime = &metav1.Time{*resp.DBCluster.EarliestRestorableTime}
	} else {
		cr.Status.AtProvider.EarliestRestorableTime = nil
	}
	if resp.DBCluster.EnabledCloudwatchLogsExports != nil {
		f30 := []*string{}
		for _, f30iter := range resp.DBCluster.EnabledCloudwatchLogsExports {
			var f30elem string
			f30elem = *f30iter
			f30 = append(f30, &f30elem)
		}
		cr.Status.AtProvider.EnabledCloudwatchLogsExports = f30
	} else {
		cr.Status.AtProvider.EnabledCloudwatchLogsExports = nil
	}
	if resp.DBCluster.Endpoint != nil {
		cr.Status.AtProvider.Endpoint = resp.DBCluster.Endpoint
	} else {
		cr.Status.AtProvider.Endpoint = nil
	}
	if resp.DBCluster.Engine != nil {
		cr.Spec.ForProvider.Engine = resp.DBCluster.Engine
	} else {
		cr.Spec.ForProvider.Engine = nil
	}
	if resp.DBCluster.EngineMode != nil {
		cr.Spec.ForProvider.EngineMode = resp.DBCluster.EngineMode
	} else {
		cr.Spec.ForProvider.EngineMode = nil
	}
	if resp.DBCluster.EngineVersion != nil {
		cr.Spec.ForProvider.EngineVersion = resp.DBCluster.EngineVersion
	} else {
		cr.Spec.ForProvider.EngineVersion = nil
	}
	if resp.DBCluster.GlobalWriteForwardingRequested != nil {
		cr.Status.AtProvider.GlobalWriteForwardingRequested = resp.DBCluster.GlobalWriteForwardingRequested
	} else {
		cr.Status.AtProvider.GlobalWriteForwardingRequested = nil
	}
	if resp.DBCluster.GlobalWriteForwardingStatus != nil {
		cr.Status.AtProvider.GlobalWriteForwardingStatus = resp.DBCluster.GlobalWriteForwardingStatus
	} else {
		cr.Status.AtProvider.GlobalWriteForwardingStatus = nil
	}
	if resp.DBCluster.HostedZoneId != nil {
		cr.Status.AtProvider.HostedZoneID = resp.DBCluster.HostedZoneId
	} else {
		cr.Status.AtProvider.HostedZoneID = nil
	}
	if resp.DBCluster.HttpEndpointEnabled != nil {
		cr.Status.AtProvider.HTTPEndpointEnabled = resp.DBCluster.HttpEndpointEnabled
	} else {
		cr.Status.AtProvider.HTTPEndpointEnabled = nil
	}
	if resp.DBCluster.IAMDatabaseAuthenticationEnabled != nil {
		cr.Status.AtProvider.IAMDatabaseAuthenticationEnabled = resp.DBCluster.IAMDatabaseAuthenticationEnabled
	} else {
		cr.Status.AtProvider.IAMDatabaseAuthenticationEnabled = nil
	}
	if resp.DBCluster.KmsKeyId != nil {
		cr.Spec.ForProvider.KMSKeyID = resp.DBCluster.KmsKeyId
	} else {
		cr.Spec.ForProvider.KMSKeyID = nil
	}
	if resp.DBCluster.LatestRestorableTime != nil {
		cr.Status.AtProvider.LatestRestorableTime = &metav1.Time{*resp.DBCluster.LatestRestorableTime}
	} else {
		cr.Status.AtProvider.LatestRestorableTime = nil
	}
	if resp.DBCluster.MasterUsername != nil {
		cr.Spec.ForProvider.MasterUsername = resp.DBCluster.MasterUsername
	} else {
		cr.Spec.ForProvider.MasterUsername = nil
	}
	if resp.DBCluster.MultiAZ != nil {
		cr.Status.AtProvider.MultiAZ = resp.DBCluster.MultiAZ
	} else {
		cr.Status.AtProvider.MultiAZ = nil
	}
	if resp.DBCluster.PercentProgress != nil {
		cr.Status.AtProvider.PercentProgress = resp.DBCluster.PercentProgress
	} else {
		cr.Status.AtProvider.PercentProgress = nil
	}
	if resp.DBCluster.Port != nil {
		cr.Spec.ForProvider.Port = resp.DBCluster.Port
	} else {
		cr.Spec.ForProvider.Port = nil
	}
	if resp.DBCluster.PreferredBackupWindow != nil {
		cr.Spec.ForProvider.PreferredBackupWindow = resp.DBCluster.PreferredBackupWindow
	} else {
		cr.Spec.ForProvider.PreferredBackupWindow = nil
	}
	if resp.DBCluster.PreferredMaintenanceWindow != nil {
		cr.Spec.ForProvider.PreferredMaintenanceWindow = resp.DBCluster.PreferredMaintenanceWindow
	} else {
		cr.Spec.ForProvider.PreferredMaintenanceWindow = nil
	}
	if resp.DBCluster.ReadReplicaIdentifiers != nil {
		f48 := []*string{}
		for _, f48iter := range resp.DBCluster.ReadReplicaIdentifiers {
			var f48elem string
			f48elem = *f48iter
			f48 = append(f48, &f48elem)
		}
		cr.Status.AtProvider.ReadReplicaIdentifiers = f48
	} else {
		cr.Status.AtProvider.ReadReplicaIdentifiers = nil
	}
	if resp.DBCluster.ReaderEndpoint != nil {
		cr.Status.AtProvider.ReaderEndpoint = resp.DBCluster.ReaderEndpoint
	} else {
		cr.Status.AtProvider.ReaderEndpoint = nil
	}
	if resp.DBCluster.ReplicationSourceIdentifier != nil {
		cr.Spec.ForProvider.ReplicationSourceIdentifier = resp.DBCluster.ReplicationSourceIdentifier
	} else {
		cr.Spec.ForProvider.ReplicationSourceIdentifier = nil
	}
	if resp.DBCluster.ScalingConfigurationInfo != nil {
		f51 := &svcapitypes.ScalingConfigurationInfo{}
		if resp.DBCluster.ScalingConfigurationInfo.AutoPause != nil {
			f51.AutoPause = resp.DBCluster.ScalingConfigurationInfo.AutoPause
		}
		if resp.DBCluster.ScalingConfigurationInfo.MaxCapacity != nil {
			f51.MaxCapacity = resp.DBCluster.ScalingConfigurationInfo.MaxCapacity
		}
		if resp.DBCluster.ScalingConfigurationInfo.MinCapacity != nil {
			f51.MinCapacity = resp.DBCluster.ScalingConfigurationInfo.MinCapacity
		}
		if resp.DBCluster.ScalingConfigurationInfo.SecondsBeforeTimeout != nil {
			f51.SecondsBeforeTimeout = resp.DBCluster.ScalingConfigurationInfo.SecondsBeforeTimeout
		}
		if resp.DBCluster.ScalingConfigurationInfo.SecondsUntilAutoPause != nil {
			f51.SecondsUntilAutoPause = resp.DBCluster.ScalingConfigurationInfo.SecondsUntilAutoPause
		}
		if resp.DBCluster.ScalingConfigurationInfo.TimeoutAction != nil {
			f51.TimeoutAction = resp.DBCluster.ScalingConfigurationInfo.TimeoutAction
		}
		cr.Status.AtProvider.ScalingConfigurationInfo = f51
	} else {
		cr.Status.AtProvider.ScalingConfigurationInfo = nil
	}
	if resp.DBCluster.Status != nil {
		cr.Status.AtProvider.Status = resp.DBCluster.Status
	} else {
		cr.Status.AtProvider.Status = nil
	}
	if resp.DBCluster.StorageEncrypted != nil {
		cr.Spec.ForProvider.StorageEncrypted = resp.DBCluster.StorageEncrypted
	} else {
		cr.Spec.ForProvider.StorageEncrypted = nil
	}
	if resp.DBCluster.TagList != nil {
		f54 := []*svcapitypes.Tag{}
		for _, f54iter := range resp.DBCluster.TagList {
			f54elem := &svcapitypes.Tag{}
			if f54iter.Key != nil {
				f54elem.Key = f54iter.Key
			}
			if f54iter.Value != nil {
				f54elem.Value = f54iter.Value
			}
			f54 = append(f54, f54elem)
		}
		cr.Status.AtProvider.TagList = f54
	} else {
		cr.Status.AtProvider.TagList = nil
	}
	if resp.DBCluster.VpcSecurityGroups != nil {
		f55 := []*svcapitypes.VPCSecurityGroupMembership{}
		for _, f55iter := range resp.DBCluster.VpcSecurityGroups {
			f55elem := &svcapitypes.VPCSecurityGroupMembership{}
			if f55iter.Status != nil {
				f55elem.Status = f55iter.Status
			}
			if f55iter.VpcSecurityGroupId != nil {
				f55elem.VPCSecurityGroupID = f55iter.VpcSecurityGroupId
			}
			f55 = append(f55, f55elem)
		}
		cr.Status.AtProvider.VPCSecurityGroups = f55
	} else {
		cr.Status.AtProvider.VPCSecurityGroups = nil
	}

	return e.postCreate(ctx, cr, resp, managed.ExternalCreation{}, err)
}

func (e *external) Update(ctx context.Context, mg cpresource.Managed) (managed.ExternalUpdate, error) {
	cr, ok := mg.(*svcapitypes.DBCluster)
	if !ok {
		return managed.ExternalUpdate{}, errors.New(errUnexpectedObject)
	}
	input := GenerateModifyDBClusterInput(cr)
	if err := e.preUpdate(ctx, cr, input); err != nil {
		return managed.ExternalUpdate{}, errors.Wrap(err, "pre-update failed")
	}
	resp, err := e.client.ModifyDBClusterWithContext(ctx, input)
	return e.postUpdate(ctx, cr, resp, managed.ExternalUpdate{}, awsclient.Wrap(err, errUpdate))
}

func (e *external) Delete(ctx context.Context, mg cpresource.Managed) error {
	cr, ok := mg.(*svcapitypes.DBCluster)
	if !ok {
		return errors.New(errUnexpectedObject)
	}
	cr.Status.SetConditions(xpv1.Deleting())
	input := GenerateDeleteDBClusterInput(cr)
	ignore, err := e.preDelete(ctx, cr, input)
	if err != nil {
		return errors.Wrap(err, "pre-delete failed")
	}
	if ignore {
		return nil
	}
	resp, err := e.client.DeleteDBClusterWithContext(ctx, input)
	return e.postDelete(ctx, cr, resp, awsclient.Wrap(cpresource.Ignore(IsNotFound, err), errDelete))
}

type option func(*external)

func newExternal(kube client.Client, client svcsdkapi.RDSAPI, opts []option) *external {
	e := &external{
		kube:           kube,
		client:         client,
		preObserve:     nopPreObserve,
		postObserve:    nopPostObserve,
		lateInitialize: nopLateInitialize,
		isUpToDate:     alwaysUpToDate,
		filterList:     nopFilterList,
		preCreate:      nopPreCreate,
		postCreate:     nopPostCreate,
		preDelete:      nopPreDelete,
		postDelete:     nopPostDelete,
		preUpdate:      nopPreUpdate,
		postUpdate:     nopPostUpdate,
	}
	for _, f := range opts {
		f(e)
	}
	return e
}

type external struct {
	kube           client.Client
	client         svcsdkapi.RDSAPI
	preObserve     func(context.Context, *svcapitypes.DBCluster, *svcsdk.DescribeDBClustersInput) error
	postObserve    func(context.Context, *svcapitypes.DBCluster, *svcsdk.DescribeDBClustersOutput, managed.ExternalObservation, error) (managed.ExternalObservation, error)
	filterList     func(*svcapitypes.DBCluster, *svcsdk.DescribeDBClustersOutput) *svcsdk.DescribeDBClustersOutput
	lateInitialize func(*svcapitypes.DBClusterParameters, *svcsdk.DescribeDBClustersOutput) error
	isUpToDate     func(*svcapitypes.DBCluster, *svcsdk.DescribeDBClustersOutput) (bool, error)
	preCreate      func(context.Context, *svcapitypes.DBCluster, *svcsdk.CreateDBClusterInput) error
	postCreate     func(context.Context, *svcapitypes.DBCluster, *svcsdk.CreateDBClusterOutput, managed.ExternalCreation, error) (managed.ExternalCreation, error)
	preDelete      func(context.Context, *svcapitypes.DBCluster, *svcsdk.DeleteDBClusterInput) (bool, error)
	postDelete     func(context.Context, *svcapitypes.DBCluster, *svcsdk.DeleteDBClusterOutput, error) error
	preUpdate      func(context.Context, *svcapitypes.DBCluster, *svcsdk.ModifyDBClusterInput) error
	postUpdate     func(context.Context, *svcapitypes.DBCluster, *svcsdk.ModifyDBClusterOutput, managed.ExternalUpdate, error) (managed.ExternalUpdate, error)
}

func nopPreObserve(context.Context, *svcapitypes.DBCluster, *svcsdk.DescribeDBClustersInput) error {
	return nil
}
func nopPostObserve(_ context.Context, _ *svcapitypes.DBCluster, _ *svcsdk.DescribeDBClustersOutput, obs managed.ExternalObservation, err error) (managed.ExternalObservation, error) {
	return obs, err
}
func nopFilterList(_ *svcapitypes.DBCluster, list *svcsdk.DescribeDBClustersOutput) *svcsdk.DescribeDBClustersOutput {
	return list
}

func nopLateInitialize(*svcapitypes.DBClusterParameters, *svcsdk.DescribeDBClustersOutput) error {
	return nil
}
func alwaysUpToDate(*svcapitypes.DBCluster, *svcsdk.DescribeDBClustersOutput) (bool, error) {
	return true, nil
}

func nopPreCreate(context.Context, *svcapitypes.DBCluster, *svcsdk.CreateDBClusterInput) error {
	return nil
}
func nopPostCreate(_ context.Context, _ *svcapitypes.DBCluster, _ *svcsdk.CreateDBClusterOutput, cre managed.ExternalCreation, err error) (managed.ExternalCreation, error) {
	return cre, err
}
func nopPreDelete(context.Context, *svcapitypes.DBCluster, *svcsdk.DeleteDBClusterInput) (bool, error) {
	return false, nil
}
func nopPostDelete(_ context.Context, _ *svcapitypes.DBCluster, _ *svcsdk.DeleteDBClusterOutput, err error) error {
	return err
}
func nopPreUpdate(context.Context, *svcapitypes.DBCluster, *svcsdk.ModifyDBClusterInput) error {
	return nil
}
func nopPostUpdate(_ context.Context, _ *svcapitypes.DBCluster, _ *svcsdk.ModifyDBClusterOutput, upd managed.ExternalUpdate, err error) (managed.ExternalUpdate, error) {
	return upd, err
}