Add a new late-init configuration to skip already filled field in spec.initProvider

[sergenyalcin]

Description of your changes

This PR adds a new late-init API to skip already filled field in spec.initProvider.

Even though a field is specified in initProvider, it is late-init for forProvider. This can cause problems in some cases because forProvider is more powerful. With this new configuration API, the late-init operation of the field in forProvider can be skipped for fields set in initProvider.

I have:

• Read and followed Upjet's contribution process.
• Run make reviewable to ensure this PR is ready for review.
• Added backport release-x.y labels to auto-backport this PR if necessary.

How has this code been tested

Tested in provider-aws by using this configuration. The example configuration for aws ec2.Subnet resource:

	p.AddResourceConfigurator("aws_subnet", func(r *config.Resource) {
		r.LateInitializer = config.LateInitializer{
			ConditionalIgnoredFields: []string{
				"cidr_block",
			},
		}
	})

Generated LateInitialize function:

func (tr *Subnet) LateInitialize(attrs []byte) (bool, error) {
	params := &SubnetParameters_2{}
	if err := json.TFParser.Unmarshal(attrs, params); err != nil {
		return false, errors.Wrap(err, "failed to unmarshal Terraform state parameters for late-initialization")
	}
	opts := []resource.GenericLateInitializerOption{resource.WithZeroValueJSONOmitEmptyFilter(resource.CNameWildcard)}
	initParams, err := tr.GetInitParameters()
	if err != nil {
		return false, errors.Wrapf(err, "cannot get init parameters for resource '%q'", tr.GetName())
	}
	opts = append(opts, resource.WithConditionalFilter("CidrBlock", initParams))

	li := resource.NewGenericLateInitializer(opts...)
	return li.LateInitialize(&tr.Spec.ForProvider, params)
}

[ulucinar]

Thank you @sergenyalcin. Left some suggestions to generalize the implementation to support other types of conditional filters that we can introduce on top of this implementation. There are some other types of conditional filters that we need to prevent certain categorical errors in addition to the race-condition preventing filter that we are adding in this PR.

We may also decide to accept the approach proposed in this PR and do a generalization in a follow-up PR. Let's discuss.

[ulucinar]

How do you feel about having a more generic configuration option on top of which we can implement this specific functionality? The idea is we could implement late-initialization filters based on the full resource specification and the canonical path being late-initialized.

We can also decide to tackle with a more generic conditional filter implementation in a follow-up PR. If we decide to do so, maybe it's better to give a more specific name to this configuration option that better reflects the specific filter it's implementing:

Suggested change

	ConditionalIgnoredFields []string
	InitProviderFields []string

The idea is there are a variety of ways we can define meaningful conditional filters. A good example is to implement a conditional filter that filters the late-initialization of fields if another mutually exclusive field is already set. We cannot cover such a filter with this implementation and hence I suggest to rename the configuration option with a more specific name to better reflect its use case.

[ulucinar]

The above discussion on choosing a more specific name is also relevant here.

[ulucinar]

Do we need to read the init parameters here? How about passing the whole resource representation to resource.ConditionalFilter when calling those filters from resource.handleStruct? Please also see the comment on resource.ConditionalFilter below.

[ulucinar]

We could make the ConditionalFilter accept the whole representation so that we can introduce different conditional filters using it:

Suggested change

	type ConditionalFilter func(string) bool
	type ConditionalFilter func(cName string, source, target *fieldpath.Paved) bool

Here source and target are the Paved representations of the source and the target objects (in the current jargon of the late-initialization library, it's the "actual" and "desired" objects, respectively). This would also allow us to get rid of reading the init parameters in the Terraformed resource's generated LateInitialize function (please see the respective comment above).

[ulucinar]

If we implement what's suggested above, we would not need the init provider map here:

Suggested change

	func WithConditionalFilter(cName string, initProvider map[string]any) GenericLateInitializerOption {
	func WithConditionalFilter(cName string) GenericLateInitializerOption {

as it would already be available in the desired object passed to the conditional filter.

[ulucinar]

This would be a specific conditional filter implementation for the very specific task of skipping a late-initialization of the spec.forProvider field iff the corresponding spec.initProvider field is already set. So, something like:

Suggested change

	func conditionalFilter(cName string, initProvider map[string]any) ConditionalFilter {
	func initProviderFilter(cName string, desired, _ *fieldpath.Paved) ConditionalFilter {

[ulucinar]

*fieldpath.Paved would be passed from resource.LateInitialize as an argument so we would not need to pave here:

Suggested change

paved := fieldpath.Pave(initProvider)

[ulucinar]

If we follow the above suggestions, this would turn into something like:

Suggested change

	if f(cName) {
	if f(cName, desiredPaved, actualPaved) {

[ulucinar]

How about accepting the actual CRD canonical path during the configuration? Then we would not need to do the conversion here.

[ulucinar]

We've sync'ed offline and decided to continue with this PR as is. We will consider the generalization of the conditions for skipping the late-initialization in future iterations. We've successfully validated this PR & #406 together in the context of crossplane-contrib/provider-upjet-aws#1311.