github.com/crossplane/upjet@v1.3.0/pkg/pipeline/templates/controller.go.tmpl

{{ .Header }}

{{ .GenStatement }}

package {{ .Package }}

import (
	"time"

	"github.com/crossplane/crossplane-runtime/pkg/connection"
	"github.com/crossplane/crossplane-runtime/pkg/event"
	"github.com/crossplane/crossplane-runtime/pkg/ratelimiter"
	"github.com/crossplane/crossplane-runtime/pkg/reconciler/managed"
	xpresource "github.com/crossplane/crossplane-runtime/pkg/resource"
	"github.com/crossplane/crossplane-runtime/pkg/statemetrics"
	"github.com/crossplane/upjet/pkg/controller/handler"
	tjcontroller "github.com/crossplane/upjet/pkg/controller"
	"github.com/crossplane/upjet/pkg/terraform"
	"github.com/pkg/errors"
	ctrl "sigs.k8s.io/controller-runtime"

	{{ .Imports }}
)

// Setup adds a controller that reconciles {{ .CRD.Kind }} managed resources.
func Setup(mgr ctrl.Manager, o tjcontroller.Options) error {
	name := managed.ControllerName({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind.String())
	var initializers managed.InitializerChain
	{{- if .Initializers }}
	for _, i := range o.Provider.Resources["{{ .ResourceType }}"].InitializerFns {
	    initializers = append(initializers,i(mgr.GetClient()))
	}
	{{- end}}
	{{- if not .DisableNameInitializer }}
	initializers = append(initializers, managed.NewNameAsExternalName(mgr.GetClient()))
	{{- end}}
	cps := []managed.ConnectionPublisher{managed.NewAPISecretPublisher(mgr.GetClient(), mgr.GetScheme())}
	if o.SecretStoreConfigGVK != nil {
		cps = append(cps, connection.NewDetailsManager(mgr.GetClient(), *o.SecretStoreConfigGVK, connection.WithTLSConfig(o.ESSOptions.TLSConfig)))
	}
	eventHandler := handler.NewEventHandler(handler.WithLogger(o.Logger.WithValues("gvk", {{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind)))
	{{- if .UseAsync }}
	ac := tjcontroller.NewAPICallbacks(mgr, xpresource.ManagedKind({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind), tjcontroller.WithEventHandler(eventHandler){{ if or .UseTerraformPluginSDKClient .UseTerraformPluginFrameworkClient }}, tjcontroller.WithStatusUpdates(false){{ end }})
	{{- end}}
	opts := []managed.ReconcilerOption{
		managed.WithExternalConnecter(
			{{- if .UseTerraformPluginSDKClient -}}
              {{- if .UseAsync }}
              tjcontroller.NewTerraformPluginSDKAsyncConnector(mgr.GetClient(), o.OperationTrackerStore, o.SetupFn, o.Provider.Resources["{{ .ResourceType }}"],
                tjcontroller.WithTerraformPluginSDKAsyncLogger(o.Logger),
                tjcontroller.WithTerraformPluginSDKAsyncConnectorEventHandler(eventHandler),
                tjcontroller.WithTerraformPluginSDKAsyncCallbackProvider(ac),
                tjcontroller.WithTerraformPluginSDKAsyncMetricRecorder(metrics.NewMetricRecorder({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind, mgr, o.PollInterval)),
                {{if .FeaturesPackageAlias -}}
                  tjcontroller.WithTerraformPluginSDKAsyncManagementPolicies(o.Features.Enabled({{ .FeaturesPackageAlias }}EnableBetaManagementPolicies))
                {{- end -}}
                )
              {{- else -}}
			  tjcontroller.NewTerraformPluginSDKConnector(mgr.GetClient(), o.SetupFn, o.Provider.Resources["{{ .ResourceType }}"], o.OperationTrackerStore,
				tjcontroller.WithTerraformPluginSDKLogger(o.Logger),
				tjcontroller.WithTerraformPluginSDKMetricRecorder(metrics.NewMetricRecorder({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind, mgr, o.PollInterval)),
				{{if .FeaturesPackageAlias -}}
				  tjcontroller.WithTerraformPluginSDKManagementPolicies(o.Features.Enabled({{ .FeaturesPackageAlias }}EnableBetaManagementPolicies))
				{{- end -}}
				)
			  {{- end -}}
			{{- else if .UseTerraformPluginFrameworkClient -}}
			  {{- if .UseAsync }}
          tjcontroller.NewTerraformPluginFrameworkAsyncConnector(mgr.GetClient(), o.OperationTrackerStore, o.SetupFn, o.Provider.Resources["{{ .ResourceType }}"],
          tjcontroller.WithTerraformPluginFrameworkAsyncLogger(o.Logger),
          tjcontroller.WithTerraformPluginFrameworkAsyncConnectorEventHandler(eventHandler),
          tjcontroller.WithTerraformPluginFrameworkAsyncCallbackProvider(ac),
          tjcontroller.WithTerraformPluginFrameworkAsyncMetricRecorder(metrics.NewMetricRecorder({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind, mgr, o.PollInterval)),
          {{if .FeaturesPackageAlias -}}
            tjcontroller.WithTerraformPluginFrameworkAsyncManagementPolicies(o.Features.Enabled({{ .FeaturesPackageAlias }}EnableBetaManagementPolicies))
          {{- end -}}
          )
			  {{- else }}
			  tjcontroller.NewTerraformPluginFrameworkConnector(mgr.GetClient(), o.SetupFn, o.Provider.Resources["{{ .ResourceType }}"], o.OperationTrackerStore,
				tjcontroller.WithTerraformPluginFrameworkLogger(o.Logger),
				tjcontroller.WithTerraformPluginFrameworkMetricRecorder(metrics.NewMetricRecorder({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind, mgr, o.PollInterval)),
				{{if .FeaturesPackageAlias -}}
				  tjcontroller.WithTerraformPluginFrameworkManagementPolicies(o.Features.Enabled({{ .FeaturesPackageAlias }}EnableBetaManagementPolicies))
				{{- end -}}
			  )
			  {{- end }}
			{{- else -}}
			  tjcontroller.NewConnector(mgr.GetClient(), o.WorkspaceStore, o.SetupFn, o.Provider.Resources["{{ .ResourceType }}"], tjcontroller.WithLogger(o.Logger), tjcontroller.WithConnectorEventHandler(eventHandler),
				{{- if .UseAsync }}
				tjcontroller.WithCallbackProvider(ac),
				{{- end }}
			  )
			{{- end -}}
		),
		managed.WithLogger(o.Logger.WithValues("controller", name)),
		managed.WithRecorder(event.NewAPIRecorder(mgr.GetEventRecorderFor(name))),
		{{- if or .UseTerraformPluginSDKClient .UseTerraformPluginFrameworkClient }}
		managed.WithFinalizer(tjcontroller.NewOperationTrackerFinalizer(o.OperationTrackerStore, xpresource.NewAPIFinalizer(mgr.GetClient(), managed.FinalizerName))),
    {{- else }}
    managed.WithFinalizer(terraform.NewWorkspaceFinalizer(o.WorkspaceStore, xpresource.NewAPIFinalizer(mgr.GetClient(), managed.FinalizerName))),
    {{- end }}
		managed.WithTimeout(3*time.Minute),
		managed.WithInitializers(initializers),
		managed.WithConnectionPublishers(cps...),
		managed.WithPollInterval(o.PollInterval),
	}
	if o.PollJitter != 0 {
	    opts = append(opts, managed.WithPollJitterHook(o.PollJitter))
	}
	{{- if .FeaturesPackageAlias }}
	if o.Features.Enabled({{ .FeaturesPackageAlias }}EnableBetaManagementPolicies) {
		opts = append(opts, managed.WithManagementPolicies())
	}
	{{- end}}
	if o.MetricOptions != nil {
		opts = append(opts, managed.WithMetricRecorder(o.MetricOptions.MRMetrics))
	}

	// register webhooks for the kind {{ .TypePackageAlias }}{{ .CRD.Kind }}
	// if they're enabled.
	if o.StartWebhooks {
		if err := ctrl.NewWebhookManagedBy(mgr).
			For(&{{ .TypePackageAlias }}{{ .CRD.Kind }}{}).
			Complete(); err != nil {
			return errors.Wrap(err, "cannot register webhook for the kind {{ .TypePackageAlias }}{{ .CRD.Kind }}")
		}
	}

	if o.MetricOptions != nil && o.MetricOptions.MRStateMetrics != nil {
		stateMetricsRecorder := statemetrics.NewMRStateRecorder(
			mgr.GetClient(), o.Logger, o.MetricOptions.MRStateMetrics, &{{ .TypePackageAlias }}{{ .CRD.Kind }}List{}, o.MetricOptions.PollStateMetricInterval,
		)
		if err := mgr.Add(stateMetricsRecorder); err != nil {
			return errors.Wrap(err, "cannot register MR state metrics recorder for kind {{ .TypePackageAlias }}{{ .CRD.Kind }}List")
		}
	}

	r := managed.NewReconciler(mgr, xpresource.ManagedKind({{ .TypePackageAlias }}{{ .CRD.Kind }}_GroupVersionKind), opts...)

	return ctrl.NewControllerManagedBy(mgr).
		Named(name).
		WithOptions(o.ForControllerRuntime()).
		WithEventFilter(xpresource.DesiredStateChanged()).
		Watches(&{{ .TypePackageAlias }}{{ .CRD.Kind }}{}, eventHandler).
		Complete(ratelimiter.NewReconciler(name, r, o.GlobalRateLimiter))
}