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 service

import (
	"context"

	svcapi "github.com/aws/aws-sdk-go/service/ecs"
	svcsdk "github.com/aws/aws-sdk-go/service/ecs"
	svcsdkapi "github.com/aws/aws-sdk-go/service/ecs/ecsiface"
	"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-contrib/provider-aws/apis/ecs/v1alpha1"
	connectaws "github.com/crossplane-contrib/provider-aws/pkg/utils/connect/aws"
	errorutils "github.com/crossplane-contrib/provider-aws/pkg/utils/errors"
)

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

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

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.Service)
	if !ok {
		return nil, errors.New(errUnexpectedObject)
	}
	sess, err := connectaws.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.Service)
	if !ok {
		return managed.ExternalObservation{}, errors.New(errUnexpectedObject)
	}
	if meta.GetExternalName(cr) == "" {
		return managed.ExternalObservation{
			ResourceExists: false,
		}, nil
	}
	input := GenerateDescribeServicesInput(cr)
	if err := e.preObserve(ctx, cr, input); err != nil {
		return managed.ExternalObservation{}, errors.Wrap(err, "pre-observe failed")
	}
	resp, err := e.client.DescribeServicesWithContext(ctx, input)
	if err != nil {
		return managed.ExternalObservation{ResourceExists: false}, errorutils.Wrap(cpresource.Ignore(IsNotFound, err), errDescribe)
	}
	currentSpec := cr.Spec.ForProvider.DeepCopy()
	if err := e.lateInitialize(&cr.Spec.ForProvider, resp); err != nil {
		return managed.ExternalObservation{}, errors.Wrap(err, "late-init failed")
	}
	GenerateService(resp).Status.AtProvider.DeepCopyInto(&cr.Status.AtProvider)
	upToDate := true
	diff := ""
	if !meta.WasDeleted(cr) { // There is no need to run isUpToDate if the resource is deleted
		upToDate, diff, err = e.isUpToDate(ctx, 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,
		Diff:                    diff,
		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.Service)
	if !ok {
		return managed.ExternalCreation{}, errors.New(errUnexpectedObject)
	}
	cr.Status.SetConditions(xpv1.Creating())
	input := GenerateCreateServiceInput(cr)
	if err := e.preCreate(ctx, cr, input); err != nil {
		return managed.ExternalCreation{}, errors.Wrap(err, "pre-create failed")
	}
	resp, err := e.client.CreateServiceWithContext(ctx, input)
	if err != nil {
		return managed.ExternalCreation{}, errorutils.Wrap(err, errCreate)
	}

	if resp.Service.CapacityProviderStrategy != nil {
		f0 := []*svcapitypes.CapacityProviderStrategyItem{}
		for _, f0iter := range resp.Service.CapacityProviderStrategy {
			f0elem := &svcapitypes.CapacityProviderStrategyItem{}
			if f0iter.Base != nil {
				f0elem.Base = f0iter.Base
			}
			if f0iter.CapacityProvider != nil {
				f0elem.CapacityProvider = f0iter.CapacityProvider
			}
			if f0iter.Weight != nil {
				f0elem.Weight = f0iter.Weight
			}
			f0 = append(f0, f0elem)
		}
		cr.Spec.ForProvider.CapacityProviderStrategy = f0
	} else {
		cr.Spec.ForProvider.CapacityProviderStrategy = nil
	}
	if resp.Service.ClusterArn != nil {
		cr.Status.AtProvider.ClusterARN = resp.Service.ClusterArn
	} else {
		cr.Status.AtProvider.ClusterARN = nil
	}
	if resp.Service.CreatedAt != nil {
		cr.Status.AtProvider.CreatedAt = &metav1.Time{*resp.Service.CreatedAt}
	} else {
		cr.Status.AtProvider.CreatedAt = nil
	}
	if resp.Service.CreatedBy != nil {
		cr.Status.AtProvider.CreatedBy = resp.Service.CreatedBy
	} else {
		cr.Status.AtProvider.CreatedBy = nil
	}
	if resp.Service.DeploymentConfiguration != nil {
		f4 := &svcapitypes.DeploymentConfiguration{}
		if resp.Service.DeploymentConfiguration.Alarms != nil {
			f4f0 := &svcapitypes.DeploymentAlarms{}
			if resp.Service.DeploymentConfiguration.Alarms.AlarmNames != nil {
				f4f0f0 := []*string{}
				for _, f4f0f0iter := range resp.Service.DeploymentConfiguration.Alarms.AlarmNames {
					var f4f0f0elem string
					f4f0f0elem = *f4f0f0iter
					f4f0f0 = append(f4f0f0, &f4f0f0elem)
				}
				f4f0.AlarmNames = f4f0f0
			}
			if resp.Service.DeploymentConfiguration.Alarms.Enable != nil {
				f4f0.Enable = resp.Service.DeploymentConfiguration.Alarms.Enable
			}
			if resp.Service.DeploymentConfiguration.Alarms.Rollback != nil {
				f4f0.Rollback = resp.Service.DeploymentConfiguration.Alarms.Rollback
			}
			f4.Alarms = f4f0
		}
		if resp.Service.DeploymentConfiguration.DeploymentCircuitBreaker != nil {
			f4f1 := &svcapitypes.DeploymentCircuitBreaker{}
			if resp.Service.DeploymentConfiguration.DeploymentCircuitBreaker.Enable != nil {
				f4f1.Enable = resp.Service.DeploymentConfiguration.DeploymentCircuitBreaker.Enable
			}
			if resp.Service.DeploymentConfiguration.DeploymentCircuitBreaker.Rollback != nil {
				f4f1.Rollback = resp.Service.DeploymentConfiguration.DeploymentCircuitBreaker.Rollback
			}
			f4.DeploymentCircuitBreaker = f4f1
		}
		if resp.Service.DeploymentConfiguration.MaximumPercent != nil {
			f4.MaximumPercent = resp.Service.DeploymentConfiguration.MaximumPercent
		}
		if resp.Service.DeploymentConfiguration.MinimumHealthyPercent != nil {
			f4.MinimumHealthyPercent = resp.Service.DeploymentConfiguration.MinimumHealthyPercent
		}
		cr.Spec.ForProvider.DeploymentConfiguration = f4
	} else {
		cr.Spec.ForProvider.DeploymentConfiguration = nil
	}
	if resp.Service.DeploymentController != nil {
		f5 := &svcapitypes.DeploymentController{}
		if resp.Service.DeploymentController.Type != nil {
			f5.Type = resp.Service.DeploymentController.Type
		}
		cr.Spec.ForProvider.DeploymentController = f5
	} else {
		cr.Spec.ForProvider.DeploymentController = nil
	}
	if resp.Service.Deployments != nil {
		f6 := []*svcapitypes.Deployment{}
		for _, f6iter := range resp.Service.Deployments {
			f6elem := &svcapitypes.Deployment{}
			if f6iter.CapacityProviderStrategy != nil {
				f6elemf0 := []*svcapitypes.CapacityProviderStrategyItem{}
				for _, f6elemf0iter := range f6iter.CapacityProviderStrategy {
					f6elemf0elem := &svcapitypes.CapacityProviderStrategyItem{}
					if f6elemf0iter.Base != nil {
						f6elemf0elem.Base = f6elemf0iter.Base
					}
					if f6elemf0iter.CapacityProvider != nil {
						f6elemf0elem.CapacityProvider = f6elemf0iter.CapacityProvider
					}
					if f6elemf0iter.Weight != nil {
						f6elemf0elem.Weight = f6elemf0iter.Weight
					}
					f6elemf0 = append(f6elemf0, f6elemf0elem)
				}
				f6elem.CapacityProviderStrategy = f6elemf0
			}
			if f6iter.CreatedAt != nil {
				f6elem.CreatedAt = &metav1.Time{*f6iter.CreatedAt}
			}
			if f6iter.DesiredCount != nil {
				f6elem.DesiredCount = f6iter.DesiredCount
			}
			if f6iter.FailedTasks != nil {
				f6elem.FailedTasks = f6iter.FailedTasks
			}
			if f6iter.Id != nil {
				f6elem.ID = f6iter.Id
			}
			if f6iter.LaunchType != nil {
				f6elem.LaunchType = f6iter.LaunchType
			}
			if f6iter.NetworkConfiguration != nil {
				f6elemf6 := &svcapitypes.NetworkConfiguration{}
				if f6iter.NetworkConfiguration.AwsvpcConfiguration != nil {
					f6elemf6f0 := &svcapitypes.AWSVPCConfiguration{}
					if f6iter.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp != nil {
						f6elemf6f0.AssignPublicIP = f6iter.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp
					}
					if f6iter.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups != nil {
						f6elemf6f0f1 := []*string{}
						for _, f6elemf6f0f1iter := range f6iter.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups {
							var f6elemf6f0f1elem string
							f6elemf6f0f1elem = *f6elemf6f0f1iter
							f6elemf6f0f1 = append(f6elemf6f0f1, &f6elemf6f0f1elem)
						}
						f6elemf6f0.SecurityGroups = f6elemf6f0f1
					}
					if f6iter.NetworkConfiguration.AwsvpcConfiguration.Subnets != nil {
						f6elemf6f0f2 := []*string{}
						for _, f6elemf6f0f2iter := range f6iter.NetworkConfiguration.AwsvpcConfiguration.Subnets {
							var f6elemf6f0f2elem string
							f6elemf6f0f2elem = *f6elemf6f0f2iter
							f6elemf6f0f2 = append(f6elemf6f0f2, &f6elemf6f0f2elem)
						}
						f6elemf6f0.Subnets = f6elemf6f0f2
					}
					f6elemf6.AWSVPCConfiguration = f6elemf6f0
				}
				f6elem.NetworkConfiguration = f6elemf6
			}
			if f6iter.PendingCount != nil {
				f6elem.PendingCount = f6iter.PendingCount
			}
			if f6iter.PlatformFamily != nil {
				f6elem.PlatformFamily = f6iter.PlatformFamily
			}
			if f6iter.PlatformVersion != nil {
				f6elem.PlatformVersion = f6iter.PlatformVersion
			}
			if f6iter.RolloutState != nil {
				f6elem.RolloutState = f6iter.RolloutState
			}
			if f6iter.RolloutStateReason != nil {
				f6elem.RolloutStateReason = f6iter.RolloutStateReason
			}
			if f6iter.RunningCount != nil {
				f6elem.RunningCount = f6iter.RunningCount
			}
			if f6iter.ServiceConnectConfiguration != nil {
				f6elemf13 := &svcapitypes.ServiceConnectConfiguration{}
				if f6iter.ServiceConnectConfiguration.Enabled != nil {
					f6elemf13.Enabled = f6iter.ServiceConnectConfiguration.Enabled
				}
				if f6iter.ServiceConnectConfiguration.LogConfiguration != nil {
					f6elemf13f1 := &svcapitypes.LogConfiguration{}
					if f6iter.ServiceConnectConfiguration.LogConfiguration.LogDriver != nil {
						f6elemf13f1.LogDriver = f6iter.ServiceConnectConfiguration.LogConfiguration.LogDriver
					}
					if f6iter.ServiceConnectConfiguration.LogConfiguration.Options != nil {
						f6elemf13f1f1 := map[string]*string{}
						for f6elemf13f1f1key, f6elemf13f1f1valiter := range f6iter.ServiceConnectConfiguration.LogConfiguration.Options {
							var f6elemf13f1f1val string
							f6elemf13f1f1val = *f6elemf13f1f1valiter
							f6elemf13f1f1[f6elemf13f1f1key] = &f6elemf13f1f1val
						}
						f6elemf13f1.Options = f6elemf13f1f1
					}
					if f6iter.ServiceConnectConfiguration.LogConfiguration.SecretOptions != nil {
						f6elemf13f1f2 := []*svcapitypes.Secret{}
						for _, f6elemf13f1f2iter := range f6iter.ServiceConnectConfiguration.LogConfiguration.SecretOptions {
							f6elemf13f1f2elem := &svcapitypes.Secret{}
							if f6elemf13f1f2iter.Name != nil {
								f6elemf13f1f2elem.Name = f6elemf13f1f2iter.Name
							}
							if f6elemf13f1f2iter.ValueFrom != nil {
								f6elemf13f1f2elem.ValueFrom = f6elemf13f1f2iter.ValueFrom
							}
							f6elemf13f1f2 = append(f6elemf13f1f2, f6elemf13f1f2elem)
						}
						f6elemf13f1.SecretOptions = f6elemf13f1f2
					}
					f6elemf13.LogConfiguration = f6elemf13f1
				}
				if f6iter.ServiceConnectConfiguration.Namespace != nil {
					f6elemf13.Namespace = f6iter.ServiceConnectConfiguration.Namespace
				}
				if f6iter.ServiceConnectConfiguration.Services != nil {
					f6elemf13f3 := []*svcapitypes.ServiceConnectService{}
					for _, f6elemf13f3iter := range f6iter.ServiceConnectConfiguration.Services {
						f6elemf13f3elem := &svcapitypes.ServiceConnectService{}
						if f6elemf13f3iter.ClientAliases != nil {
							f6elemf13f3elemf0 := []*svcapitypes.ServiceConnectClientAlias{}
							for _, f6elemf13f3elemf0iter := range f6elemf13f3iter.ClientAliases {
								f6elemf13f3elemf0elem := &svcapitypes.ServiceConnectClientAlias{}
								if f6elemf13f3elemf0iter.DnsName != nil {
									f6elemf13f3elemf0elem.DNSName = f6elemf13f3elemf0iter.DnsName
								}
								if f6elemf13f3elemf0iter.Port != nil {
									f6elemf13f3elemf0elem.Port = f6elemf13f3elemf0iter.Port
								}
								f6elemf13f3elemf0 = append(f6elemf13f3elemf0, f6elemf13f3elemf0elem)
							}
							f6elemf13f3elem.ClientAliases = f6elemf13f3elemf0
						}
						if f6elemf13f3iter.DiscoveryName != nil {
							f6elemf13f3elem.DiscoveryName = f6elemf13f3iter.DiscoveryName
						}
						if f6elemf13f3iter.IngressPortOverride != nil {
							f6elemf13f3elem.IngressPortOverride = f6elemf13f3iter.IngressPortOverride
						}
						if f6elemf13f3iter.PortName != nil {
							f6elemf13f3elem.PortName = f6elemf13f3iter.PortName
						}
						f6elemf13f3 = append(f6elemf13f3, f6elemf13f3elem)
					}
					f6elemf13.Services = f6elemf13f3
				}
				f6elem.ServiceConnectConfiguration = f6elemf13
			}
			if f6iter.ServiceConnectResources != nil {
				f6elemf14 := []*svcapitypes.ServiceConnectServiceResource{}
				for _, f6elemf14iter := range f6iter.ServiceConnectResources {
					f6elemf14elem := &svcapitypes.ServiceConnectServiceResource{}
					if f6elemf14iter.DiscoveryArn != nil {
						f6elemf14elem.DiscoveryARN = f6elemf14iter.DiscoveryArn
					}
					if f6elemf14iter.DiscoveryName != nil {
						f6elemf14elem.DiscoveryName = f6elemf14iter.DiscoveryName
					}
					f6elemf14 = append(f6elemf14, f6elemf14elem)
				}
				f6elem.ServiceConnectResources = f6elemf14
			}
			if f6iter.Status != nil {
				f6elem.Status = f6iter.Status
			}
			if f6iter.TaskDefinition != nil {
				f6elem.TaskDefinition = f6iter.TaskDefinition
			}
			if f6iter.UpdatedAt != nil {
				f6elem.UpdatedAt = &metav1.Time{*f6iter.UpdatedAt}
			}
			f6 = append(f6, f6elem)
		}
		cr.Status.AtProvider.Deployments = f6
	} else {
		cr.Status.AtProvider.Deployments = nil
	}
	if resp.Service.DesiredCount != nil {
		cr.Spec.ForProvider.DesiredCount = resp.Service.DesiredCount
	} else {
		cr.Spec.ForProvider.DesiredCount = nil
	}
	if resp.Service.EnableECSManagedTags != nil {
		cr.Spec.ForProvider.EnableECSManagedTags = resp.Service.EnableECSManagedTags
	} else {
		cr.Spec.ForProvider.EnableECSManagedTags = nil
	}
	if resp.Service.EnableExecuteCommand != nil {
		cr.Spec.ForProvider.EnableExecuteCommand = resp.Service.EnableExecuteCommand
	} else {
		cr.Spec.ForProvider.EnableExecuteCommand = nil
	}
	if resp.Service.Events != nil {
		f10 := []*svcapitypes.ServiceEvent{}
		for _, f10iter := range resp.Service.Events {
			f10elem := &svcapitypes.ServiceEvent{}
			if f10iter.CreatedAt != nil {
				f10elem.CreatedAt = &metav1.Time{*f10iter.CreatedAt}
			}
			if f10iter.Id != nil {
				f10elem.ID = f10iter.Id
			}
			if f10iter.Message != nil {
				f10elem.Message = f10iter.Message
			}
			f10 = append(f10, f10elem)
		}
		cr.Status.AtProvider.Events = f10
	} else {
		cr.Status.AtProvider.Events = nil
	}
	if resp.Service.HealthCheckGracePeriodSeconds != nil {
		cr.Spec.ForProvider.HealthCheckGracePeriodSeconds = resp.Service.HealthCheckGracePeriodSeconds
	} else {
		cr.Spec.ForProvider.HealthCheckGracePeriodSeconds = nil
	}
	if resp.Service.LaunchType != nil {
		cr.Spec.ForProvider.LaunchType = resp.Service.LaunchType
	} else {
		cr.Spec.ForProvider.LaunchType = nil
	}
	if resp.Service.LoadBalancers != nil {
		f13 := []*svcapitypes.LoadBalancer{}
		for _, f13iter := range resp.Service.LoadBalancers {
			f13elem := &svcapitypes.LoadBalancer{}
			if f13iter.ContainerName != nil {
				f13elem.ContainerName = f13iter.ContainerName
			}
			if f13iter.ContainerPort != nil {
				f13elem.ContainerPort = f13iter.ContainerPort
			}
			if f13iter.LoadBalancerName != nil {
				f13elem.LoadBalancerName = f13iter.LoadBalancerName
			}
			if f13iter.TargetGroupArn != nil {
				f13elem.TargetGroupARN = f13iter.TargetGroupArn
			}
			f13 = append(f13, f13elem)
		}
		cr.Status.AtProvider.LoadBalancers = f13
	} else {
		cr.Status.AtProvider.LoadBalancers = nil
	}
	if resp.Service.NetworkConfiguration != nil {
		f14 := &svcapitypes.NetworkConfiguration{}
		if resp.Service.NetworkConfiguration.AwsvpcConfiguration != nil {
			f14f0 := &svcapitypes.AWSVPCConfiguration{}
			if resp.Service.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp != nil {
				f14f0.AssignPublicIP = resp.Service.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp
			}
			if resp.Service.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups != nil {
				f14f0f1 := []*string{}
				for _, f14f0f1iter := range resp.Service.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups {
					var f14f0f1elem string
					f14f0f1elem = *f14f0f1iter
					f14f0f1 = append(f14f0f1, &f14f0f1elem)
				}
				f14f0.SecurityGroups = f14f0f1
			}
			if resp.Service.NetworkConfiguration.AwsvpcConfiguration.Subnets != nil {
				f14f0f2 := []*string{}
				for _, f14f0f2iter := range resp.Service.NetworkConfiguration.AwsvpcConfiguration.Subnets {
					var f14f0f2elem string
					f14f0f2elem = *f14f0f2iter
					f14f0f2 = append(f14f0f2, &f14f0f2elem)
				}
				f14f0.Subnets = f14f0f2
			}
			f14.AWSVPCConfiguration = f14f0
		}
		cr.Status.AtProvider.NetworkConfiguration = f14
	} else {
		cr.Status.AtProvider.NetworkConfiguration = nil
	}
	if resp.Service.PendingCount != nil {
		cr.Status.AtProvider.PendingCount = resp.Service.PendingCount
	} else {
		cr.Status.AtProvider.PendingCount = nil
	}
	if resp.Service.PlacementConstraints != nil {
		f16 := []*svcapitypes.PlacementConstraint{}
		for _, f16iter := range resp.Service.PlacementConstraints {
			f16elem := &svcapitypes.PlacementConstraint{}
			if f16iter.Expression != nil {
				f16elem.Expression = f16iter.Expression
			}
			if f16iter.Type != nil {
				f16elem.Type = f16iter.Type
			}
			f16 = append(f16, f16elem)
		}
		cr.Spec.ForProvider.PlacementConstraints = f16
	} else {
		cr.Spec.ForProvider.PlacementConstraints = nil
	}
	if resp.Service.PlacementStrategy != nil {
		f17 := []*svcapitypes.PlacementStrategy{}
		for _, f17iter := range resp.Service.PlacementStrategy {
			f17elem := &svcapitypes.PlacementStrategy{}
			if f17iter.Field != nil {
				f17elem.Field = f17iter.Field
			}
			if f17iter.Type != nil {
				f17elem.Type = f17iter.Type
			}
			f17 = append(f17, f17elem)
		}
		cr.Spec.ForProvider.PlacementStrategy = f17
	} else {
		cr.Spec.ForProvider.PlacementStrategy = nil
	}
	if resp.Service.PlatformFamily != nil {
		cr.Status.AtProvider.PlatformFamily = resp.Service.PlatformFamily
	} else {
		cr.Status.AtProvider.PlatformFamily = nil
	}
	if resp.Service.PlatformVersion != nil {
		cr.Spec.ForProvider.PlatformVersion = resp.Service.PlatformVersion
	} else {
		cr.Spec.ForProvider.PlatformVersion = nil
	}
	if resp.Service.PropagateTags != nil {
		cr.Spec.ForProvider.PropagateTags = resp.Service.PropagateTags
	} else {
		cr.Spec.ForProvider.PropagateTags = nil
	}
	if resp.Service.RoleArn != nil {
		cr.Status.AtProvider.RoleARN = resp.Service.RoleArn
	} else {
		cr.Status.AtProvider.RoleARN = nil
	}
	if resp.Service.RunningCount != nil {
		cr.Status.AtProvider.RunningCount = resp.Service.RunningCount
	} else {
		cr.Status.AtProvider.RunningCount = nil
	}
	if resp.Service.SchedulingStrategy != nil {
		cr.Spec.ForProvider.SchedulingStrategy = resp.Service.SchedulingStrategy
	} else {
		cr.Spec.ForProvider.SchedulingStrategy = nil
	}
	if resp.Service.ServiceArn != nil {
		cr.Status.AtProvider.ServiceARN = resp.Service.ServiceArn
	} else {
		cr.Status.AtProvider.ServiceARN = nil
	}
	if resp.Service.ServiceName != nil {
		cr.Status.AtProvider.ServiceName = resp.Service.ServiceName
	} else {
		cr.Status.AtProvider.ServiceName = nil
	}
	if resp.Service.ServiceRegistries != nil {
		f26 := []*svcapitypes.ServiceRegistry{}
		for _, f26iter := range resp.Service.ServiceRegistries {
			f26elem := &svcapitypes.ServiceRegistry{}
			if f26iter.ContainerName != nil {
				f26elem.ContainerName = f26iter.ContainerName
			}
			if f26iter.ContainerPort != nil {
				f26elem.ContainerPort = f26iter.ContainerPort
			}
			if f26iter.Port != nil {
				f26elem.Port = f26iter.Port
			}
			if f26iter.RegistryArn != nil {
				f26elem.RegistryARN = f26iter.RegistryArn
			}
			f26 = append(f26, f26elem)
		}
		cr.Spec.ForProvider.ServiceRegistries = f26
	} else {
		cr.Spec.ForProvider.ServiceRegistries = nil
	}
	if resp.Service.Status != nil {
		cr.Status.AtProvider.Status = resp.Service.Status
	} else {
		cr.Status.AtProvider.Status = nil
	}
	if resp.Service.Tags != nil {
		f28 := []*svcapitypes.Tag{}
		for _, f28iter := range resp.Service.Tags {
			f28elem := &svcapitypes.Tag{}
			if f28iter.Key != nil {
				f28elem.Key = f28iter.Key
			}
			if f28iter.Value != nil {
				f28elem.Value = f28iter.Value
			}
			f28 = append(f28, f28elem)
		}
		cr.Spec.ForProvider.Tags = f28
	} else {
		cr.Spec.ForProvider.Tags = nil
	}
	if resp.Service.TaskDefinition != nil {
		cr.Status.AtProvider.TaskDefinition = resp.Service.TaskDefinition
	} else {
		cr.Status.AtProvider.TaskDefinition = nil
	}
	if resp.Service.TaskSets != nil {
		f30 := []*svcapitypes.TaskSet{}
		for _, f30iter := range resp.Service.TaskSets {
			f30elem := &svcapitypes.TaskSet{}
			if f30iter.CapacityProviderStrategy != nil {
				f30elemf0 := []*svcapitypes.CapacityProviderStrategyItem{}
				for _, f30elemf0iter := range f30iter.CapacityProviderStrategy {
					f30elemf0elem := &svcapitypes.CapacityProviderStrategyItem{}
					if f30elemf0iter.Base != nil {
						f30elemf0elem.Base = f30elemf0iter.Base
					}
					if f30elemf0iter.CapacityProvider != nil {
						f30elemf0elem.CapacityProvider = f30elemf0iter.CapacityProvider
					}
					if f30elemf0iter.Weight != nil {
						f30elemf0elem.Weight = f30elemf0iter.Weight
					}
					f30elemf0 = append(f30elemf0, f30elemf0elem)
				}
				f30elem.CapacityProviderStrategy = f30elemf0
			}
			if f30iter.ClusterArn != nil {
				f30elem.ClusterARN = f30iter.ClusterArn
			}
			if f30iter.ComputedDesiredCount != nil {
				f30elem.ComputedDesiredCount = f30iter.ComputedDesiredCount
			}
			if f30iter.CreatedAt != nil {
				f30elem.CreatedAt = &metav1.Time{*f30iter.CreatedAt}
			}
			if f30iter.ExternalId != nil {
				f30elem.ExternalID = f30iter.ExternalId
			}
			if f30iter.Id != nil {
				f30elem.ID = f30iter.Id
			}
			if f30iter.LaunchType != nil {
				f30elem.LaunchType = f30iter.LaunchType
			}
			if f30iter.LoadBalancers != nil {
				f30elemf7 := []*svcapitypes.LoadBalancer{}
				for _, f30elemf7iter := range f30iter.LoadBalancers {
					f30elemf7elem := &svcapitypes.LoadBalancer{}
					if f30elemf7iter.ContainerName != nil {
						f30elemf7elem.ContainerName = f30elemf7iter.ContainerName
					}
					if f30elemf7iter.ContainerPort != nil {
						f30elemf7elem.ContainerPort = f30elemf7iter.ContainerPort
					}
					if f30elemf7iter.LoadBalancerName != nil {
						f30elemf7elem.LoadBalancerName = f30elemf7iter.LoadBalancerName
					}
					if f30elemf7iter.TargetGroupArn != nil {
						f30elemf7elem.TargetGroupARN = f30elemf7iter.TargetGroupArn
					}
					f30elemf7 = append(f30elemf7, f30elemf7elem)
				}
				f30elem.LoadBalancers = f30elemf7
			}
			if f30iter.NetworkConfiguration != nil {
				f30elemf8 := &svcapitypes.NetworkConfiguration{}
				if f30iter.NetworkConfiguration.AwsvpcConfiguration != nil {
					f30elemf8f0 := &svcapitypes.AWSVPCConfiguration{}
					if f30iter.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp != nil {
						f30elemf8f0.AssignPublicIP = f30iter.NetworkConfiguration.AwsvpcConfiguration.AssignPublicIp
					}
					if f30iter.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups != nil {
						f30elemf8f0f1 := []*string{}
						for _, f30elemf8f0f1iter := range f30iter.NetworkConfiguration.AwsvpcConfiguration.SecurityGroups {
							var f30elemf8f0f1elem string
							f30elemf8f0f1elem = *f30elemf8f0f1iter
							f30elemf8f0f1 = append(f30elemf8f0f1, &f30elemf8f0f1elem)
						}
						f30elemf8f0.SecurityGroups = f30elemf8f0f1
					}
					if f30iter.NetworkConfiguration.AwsvpcConfiguration.Subnets != nil {
						f30elemf8f0f2 := []*string{}
						for _, f30elemf8f0f2iter := range f30iter.NetworkConfiguration.AwsvpcConfiguration.Subnets {
							var f30elemf8f0f2elem string
							f30elemf8f0f2elem = *f30elemf8f0f2iter
							f30elemf8f0f2 = append(f30elemf8f0f2, &f30elemf8f0f2elem)
						}
						f30elemf8f0.Subnets = f30elemf8f0f2
					}
					f30elemf8.AWSVPCConfiguration = f30elemf8f0
				}
				f30elem.NetworkConfiguration = f30elemf8
			}
			if f30iter.PendingCount != nil {
				f30elem.PendingCount = f30iter.PendingCount
			}
			if f30iter.PlatformFamily != nil {
				f30elem.PlatformFamily = f30iter.PlatformFamily
			}
			if f30iter.PlatformVersion != nil {
				f30elem.PlatformVersion = f30iter.PlatformVersion
			}
			if f30iter.RunningCount != nil {
				f30elem.RunningCount = f30iter.RunningCount
			}
			if f30iter.Scale != nil {
				f30elemf13 := &svcapitypes.Scale{}
				if f30iter.Scale.Unit != nil {
					f30elemf13.Unit = f30iter.Scale.Unit
				}
				if f30iter.Scale.Value != nil {
					f30elemf13.Value = f30iter.Scale.Value
				}
				f30elem.Scale = f30elemf13
			}
			if f30iter.ServiceArn != nil {
				f30elem.ServiceARN = f30iter.ServiceArn
			}
			if f30iter.ServiceRegistries != nil {
				f30elemf15 := []*svcapitypes.ServiceRegistry{}
				for _, f30elemf15iter := range f30iter.ServiceRegistries {
					f30elemf15elem := &svcapitypes.ServiceRegistry{}
					if f30elemf15iter.ContainerName != nil {
						f30elemf15elem.ContainerName = f30elemf15iter.ContainerName
					}
					if f30elemf15iter.ContainerPort != nil {
						f30elemf15elem.ContainerPort = f30elemf15iter.ContainerPort
					}
					if f30elemf15iter.Port != nil {
						f30elemf15elem.Port = f30elemf15iter.Port
					}
					if f30elemf15iter.RegistryArn != nil {
						f30elemf15elem.RegistryARN = f30elemf15iter.RegistryArn
					}
					f30elemf15 = append(f30elemf15, f30elemf15elem)
				}
				f30elem.ServiceRegistries = f30elemf15
			}
			if f30iter.StabilityStatus != nil {
				f30elem.StabilityStatus = f30iter.StabilityStatus
			}
			if f30iter.StabilityStatusAt != nil {
				f30elem.StabilityStatusAt = &metav1.Time{*f30iter.StabilityStatusAt}
			}
			if f30iter.StartedBy != nil {
				f30elem.StartedBy = f30iter.StartedBy
			}
			if f30iter.Status != nil {
				f30elem.Status = f30iter.Status
			}
			if f30iter.Tags != nil {
				f30elemf20 := []*svcapitypes.Tag{}
				for _, f30elemf20iter := range f30iter.Tags {
					f30elemf20elem := &svcapitypes.Tag{}
					if f30elemf20iter.Key != nil {
						f30elemf20elem.Key = f30elemf20iter.Key
					}
					if f30elemf20iter.Value != nil {
						f30elemf20elem.Value = f30elemf20iter.Value
					}
					f30elemf20 = append(f30elemf20, f30elemf20elem)
				}
				f30elem.Tags = f30elemf20
			}
			if f30iter.TaskDefinition != nil {
				f30elem.TaskDefinition = f30iter.TaskDefinition
			}
			if f30iter.TaskSetArn != nil {
				f30elem.TaskSetARN = f30iter.TaskSetArn
			}
			if f30iter.UpdatedAt != nil {
				f30elem.UpdatedAt = &metav1.Time{*f30iter.UpdatedAt}
			}
			f30 = append(f30, f30elem)
		}
		cr.Status.AtProvider.TaskSets = f30
	} else {
		cr.Status.AtProvider.TaskSets = 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.Service)
	if !ok {
		return managed.ExternalUpdate{}, errors.New(errUnexpectedObject)
	}
	input := GenerateUpdateServiceInput(cr)
	if err := e.preUpdate(ctx, cr, input); err != nil {
		return managed.ExternalUpdate{}, errors.Wrap(err, "pre-update failed")
	}
	resp, err := e.client.UpdateServiceWithContext(ctx, input)
	return e.postUpdate(ctx, cr, resp, managed.ExternalUpdate{}, errorutils.Wrap(err, errUpdate))
}

func (e *external) Delete(ctx context.Context, mg cpresource.Managed) error {
	cr, ok := mg.(*svcapitypes.Service)
	if !ok {
		return errors.New(errUnexpectedObject)
	}
	cr.Status.SetConditions(xpv1.Deleting())
	input := GenerateDeleteServiceInput(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.DeleteServiceWithContext(ctx, input)
	return e.postDelete(ctx, cr, resp, errorutils.Wrap(cpresource.Ignore(IsNotFound, err), errDelete))
}

type option func(*external)

func newExternal(kube client.Client, client svcsdkapi.ECSAPI, opts []option) *external {
	e := &external{
		kube:           kube,
		client:         client,
		preObserve:     nopPreObserve,
		postObserve:    nopPostObserve,
		lateInitialize: nopLateInitialize,
		isUpToDate:     alwaysUpToDate,
		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.ECSAPI
	preObserve     func(context.Context, *svcapitypes.Service, *svcsdk.DescribeServicesInput) error
	postObserve    func(context.Context, *svcapitypes.Service, *svcsdk.DescribeServicesOutput, managed.ExternalObservation, error) (managed.ExternalObservation, error)
	lateInitialize func(*svcapitypes.ServiceParameters, *svcsdk.DescribeServicesOutput) error
	isUpToDate     func(context.Context, *svcapitypes.Service, *svcsdk.DescribeServicesOutput) (bool, string, error)
	preCreate      func(context.Context, *svcapitypes.Service, *svcsdk.CreateServiceInput) error
	postCreate     func(context.Context, *svcapitypes.Service, *svcsdk.CreateServiceOutput, managed.ExternalCreation, error) (managed.ExternalCreation, error)
	preDelete      func(context.Context, *svcapitypes.Service, *svcsdk.DeleteServiceInput) (bool, error)
	postDelete     func(context.Context, *svcapitypes.Service, *svcsdk.DeleteServiceOutput, error) error
	preUpdate      func(context.Context, *svcapitypes.Service, *svcsdk.UpdateServiceInput) error
	postUpdate     func(context.Context, *svcapitypes.Service, *svcsdk.UpdateServiceOutput, managed.ExternalUpdate, error) (managed.ExternalUpdate, error)
}

func nopPreObserve(context.Context, *svcapitypes.Service, *svcsdk.DescribeServicesInput) error {
	return nil
}

func nopPostObserve(_ context.Context, _ *svcapitypes.Service, _ *svcsdk.DescribeServicesOutput, obs managed.ExternalObservation, err error) (managed.ExternalObservation, error) {
	return obs, err
}
func nopLateInitialize(*svcapitypes.ServiceParameters, *svcsdk.DescribeServicesOutput) error {
	return nil
}
func alwaysUpToDate(context.Context, *svcapitypes.Service, *svcsdk.DescribeServicesOutput) (bool, string, error) {
	return true, "", nil
}

func nopPreCreate(context.Context, *svcapitypes.Service, *svcsdk.CreateServiceInput) error {
	return nil
}
func nopPostCreate(_ context.Context, _ *svcapitypes.Service, _ *svcsdk.CreateServiceOutput, cre managed.ExternalCreation, err error) (managed.ExternalCreation, error) {
	return cre, err
}
func nopPreDelete(context.Context, *svcapitypes.Service, *svcsdk.DeleteServiceInput) (bool, error) {
	return false, nil
}
func nopPostDelete(_ context.Context, _ *svcapitypes.Service, _ *svcsdk.DeleteServiceOutput, err error) error {
	return err
}
func nopPreUpdate(context.Context, *svcapitypes.Service, *svcsdk.UpdateServiceInput) error {
	return nil
}
func nopPostUpdate(_ context.Context, _ *svcapitypes.Service, _ *svcsdk.UpdateServiceOutput, upd managed.ExternalUpdate, err error) (managed.ExternalUpdate, error) {
	return upd, err
}