WIP - deal with diff Go types

Adds a new SetFieldConfig struct to the code generator config that
allows teams to instruct the code generator to handle the SetResource
generator specially for a particular `pkg/model.OpType`.

This is useful for at least a couple use cases:

1. Different Go types in input and output shapes

When the Go type of a field in the Create Input shape differs from the
Go type of the same-named field in another operation's Output shape, the
code generator doesn't know how to handle this situation and ends up
outputting invalid Go code.

An example of this behaviour is in the RDS controller's DBInstance
resource. The DBSecurityGroups field in the Create Input shape is of
type `[]*string`, but the same field in the Create, ReadMany and Update
output shapes is of type `[]*DBSecurityGroupMembership`. The
`DBSecurityGroupMembership` struct has two fields, `DBSecurityGroupName`
and `Status`. The only part of that struct that is relevant to the
`Spec.DBSecurityGroups` field is the `DBSecurityGroupName` field, which
corresponds to the string identifier of the DB security group provided
by the user in the `CreateDBInstanceRequest.DBSecurityGroups` field.

The code generator ends up calling `pkg/generate/code.SetResource` for
the DBInstance resource, gets to the `Spec.DBSecurityGroups` field and
just doesn't know how to handle the different Go types and so ends up
outputting nothing, which breaks compilation and has caused us to
manually comment out or fix the generated code.  operation.

See: https://github.com/aws-controllers-k8s/rds-controller/blob/dc3271fa7b455fc99c3531ce372ea221c9f5b8e7/pkg/resource/db_instance/sdk.go#L853-L864

In the RDS DBInstance DBSecurityGroups case, we'd add the following to
the RDS generator.yaml file to instruct the code generator how to
transform the response from the DescribeDBInstances Output shape for
setting the value of `Spec.DBSecurityGroups` from the set of
`DBSecurityGroupMembership.DBSecurityGroupName` values:

```yaml
resources:
  DBInstance:
    fields:
      DBSecurityGroups:
        set:
         - on: READ_MANY
           from: DBSecurityGroupName
```

2. Ignoring fields in output shapes containing stale data

For some service APIs, the returned value for a field in the Output
shape of an Update operation contains the *originally-set* value instead
of the value of the field that was set in the Update operation itself.

An example of this situation is the ElastiCache ModifyReplicationGroup
API call. If you pass some value for the LogDeliveryConfiguration field
in the Input shape (which comes from the Spec.LogDeliveryConfiguration
field of the ReplicationGroup resource), the value that is returned in
the Output shape's LogDeliveryConfiguration is actually the *old*
(stale) value for the field. The reason for this return of stale data is
because the log delivery configuration is asynchronously mutated.

For these cases, we want to be able to tell the code generator to ignore
these fields when outputting code for the
`pkg/generate/code.SetResource` function, but only for the Update
operation. In this case, we'd add the following to the ElastiCache
generator.yaml file:

```yaml
resources:
  ReplicationGroup:
    fields:
      LogDeliveryConfiguration:
        set:
         - on: UPDATE
           ignore: true
```

Signed-off-by: Jay Pipes <[email protected]>

Author: jaypipes

pkg/generate/code/set_resource.go

@@ -217,6 +217,15 @@ func SetResource(
 			targetAdaptedVarName += cfg.PrefixConfig.StatusField
 		}
 		targetMemberShapeRef = f.ShapeRef
+
+		// We may have some special instructions for how to handle setting the
+		// field value...
+		setCfg := f.GetSetterConfig(opType)
+
+		if setCfg != nil && setCfg.Ignore {
+			continue
+		}
+
 		// fieldVarName is the name of the variable that is used for temporary
 		// storage of complex member field values
 		//
@@ -500,6 +509,15 @@ func setResourceReadMany(
 			}
 			targetAdaptedVarName += cfg.PrefixConfig.StatusField
 		}
+
+		// We may have some special instructions for how to handle setting the
+		// field value...
+		setCfg := f.GetSetterConfig(model.OpTypeList)
+
+		if setCfg != nil && setCfg.Ignore {
+			continue
+		}
+
 		targetMemberShapeRef = f.ShapeRef
 		out += fmt.Sprintf(
 			"%s\tif %s != nil {\n", indent, sourceAdaptedVarName,

pkg/generate/code/set_sdk.go

@@ -1136,6 +1136,7 @@ func setSDKForSlice(
 		targetShape.MemberRef.Shape,
 		indentLevel+1,
 	)
+
 	//  f0elem = *f0iter
 	//
 	// or

pkg/generate/config/field.go

@@ -105,6 +105,106 @@ type SourceFieldConfig struct {
 	Path string `json:"path"`
 }
 
+// SetFieldConfig instructs the code generator how to handle setting the value
+// of the field from an Output shape in the API response.
+//
+// These instructions are necessary when the Go type for Input and Output
+// fields is different.
+//
+// For example, consider the `DBSecurityGroups` field for an RDS `DBInstance`
+// resource.
+//
+// The Create operation's Input shape's `DBSecurityGroups` field has a Go type
+// of `[]*string` [0] because the user is expected to provide a list of
+// DBSecurityGroup identifiers when creating the DBInstance.
+//
+// However, the Output shape for both the Create and ReadOne operation uses a
+// different Go type for the `DBSecurityGroups` field. For these Output shapes,
+// the Go type is `[]*DBSecurityGroupMembership` [1]. The
+// `DBSecurityGroupMembership` struct contains the DBSecurityGroup's name and
+// "status".
+//
+// The challenge that the ACK code generator has is to figure out how to take
+// the Go type of the Output shape and process it into the Go type of the Input
+// shape.
+//
+// In other words, for the `DBInstance.Spec.DBSecurityGroups` field discussed
+// above, we need to have the code generator produce the following Go code in
+// the SetResource generator:
+//
+// ```go
+// if resp.DBInstance.DBSecurityGroups != nil {
+//     f17 := []*string{}
+//     for _, f17iter := range resp.DBInstance.DBSecurityGroups {
+//         var f17elem string
+//         f17elem = *f17iter.DBSecurityGroupName
+//         f17 = append(f17, &f17elem)
+//     }
+//     ko.Spec.DBSecurityGroupNames = f17
+// } else {
+//     ko.Spec.DBSecurityGroupNames = nil
+// }
+// ```
+//
+// [0] https://github.com/aws/aws-sdk-go/blob/0a01aef9caf16d869c7340e729080205760dc2a2/models/apis/rds/2014-10-31/api-2.json#L2985
+// [1] https://github.com/aws/aws-sdk-go/blob/0a01aef9caf16d869c7340e729080205760dc2a2/models/apis/rds/2014-10-31/api-2.json#L3815
+type SetFieldConfig struct {
+	// On is the `pkg/model.OpType` whose Output shape will be transformed by
+	// this config. If empty, this set field config applies to all operations
+	On *string `json:on,omitempty`
+	// MemberAccessPath tells the code generator to output Go code that sets
+	// the value of a variable containing the target resource field with the
+	// contents of a member field in the source struct.
+	//
+	// Consider the `DBInstance.Spec.DBSecurityGroups` field discussed above.
+	//
+	// If we have the following generator.yaml config:
+	//
+	// ```yaml
+	// resources:
+	//   DBInstance:
+	//     fields:
+	//       DBSecurityGroups:
+	//         set:
+	//           - on: CREATE
+	//			   from: DBSecurityGroupName
+	//           - on: READ_ONE
+	//			   from: DBSecurityGroupName
+	// ```
+	//
+	// That will instruct the code generator to output this Go code when
+	// processing the `*DBSecurityGroupMembership` struct elements of the
+	// Output shape's DBSecurityGroups field:
+	//
+	// ```go
+	// f17elem = *f17iter.DBSecurityGroupName
+	// ```
+	From *string `json:"from,omitempty"`
+	// Ignore instructs the code generator to ignore this field in the Output
+	// shape when setting the value of the resource's field in the Spec. This
+	// is useful when we know that, for example, the returned value of field in
+	// an Output shape contains stale data, such as when the ElastiCache
+	// ModifyReplicationGroup API's Output response shape contains the
+	// originally-set value for the LogDeliveryConfiguration field that was
+	// updated in the Input shape.
+	//
+	// See: https://github.com/aws-controllers-k8s/elasticache-controller/pull/59/
+	//
+	// In the case of ElastiCache, we might have the following generator.yaml
+	// config:
+	//
+	// ```yaml
+	// resources:
+	//   ReplicationGroup:
+	//     fields:
+	//       LogDeliveryConfiguration:
+	//         set:
+	//           - on: UPDATE
+	//			   ignore: true
+	// ```
+	Ignore bool `json:"ignore,omitempty"`
+}
+
 // CompareFieldConfig informs the code generator how to compare two values of a
 // field
 type CompareFieldConfig struct {
@@ -196,6 +296,10 @@ type FieldConfig struct {
 	// Compare instructs the code generator how to produce code that compares
 	// the value of the field in two resources
 	Compare *CompareFieldConfig `json:"compare,omitempty"`
+	// Set contains instructions for the code generator how to deal with
+	// fields where the Go type of the same-named fields in an Output shape is
+	// different from the Go type of the Input shape.
+	Set []*SetFieldConfig `json:"set"`
 	// Print instructs the code generator how to generate comment markers that
 	// influence hows field are printed in `kubectl get` response. If this field
 	// is not nil, it will be added to the columns of `kubectl get`.

pkg/model/field.go

@@ -63,6 +63,20 @@ func (f *Field) IsRequired() bool {
 	return util.InStrings(f.Names.ModelOriginal, f.CRD.Ops.Create.InputRef.Shape.Required)
 }
 
+// GetSetterConfig returns the SetFieldConfig object associated with this field
+// and a supplied operation type, or nil if none exists.
+func (f *Field) GetSetterConfig(opType OpType) *ackgenconfig.SetFieldConfig {
+	if f.FieldConfig == nil {
+		return nil
+	}
+	for _, setCfg := range f.FieldConfig.Set {
+		if setCfg.On == nil || OpTypeFromString(*setCfg.On) == opType {
+			return setCfg
+		}
+	}
+	return nil
+}
+
 // ParentFieldPath takes a field path and returns the field path of the
 // containing "parent" field. For example, if the field path
 // `Users..Credentials.Login` is passed in, this function returns