Fix errors from breaking changes in kin-openapi

Author: alexsomesan

manifest/openapi/foundry_v2.go

@@ -100,19 +100,19 @@ func (f *foapiv2) getTypeByID(id string, h map[string]string, ap tftypes.Attribu
 		return nil, errors.New("invalid type reference (nil)")
 	}
 
-	sch, err := resolveSchemaRef(swd, f.swagger.Definitions)
+	sch, err := resolveSchemaRef2(swd, f.swagger.Definitions)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve schema: %s", err)
 	}
 
-	return getTypeFromSchema(sch, f.recursionDepth, &(f.typeCache), f.swagger.Definitions, ap, h)
+	return getTypeFromSchema2(sch, f.recursionDepth, &(f.typeCache), f.swagger.Definitions, ap, h)
 }
 
 // buildGvkIndex builds the reverse lookup index that associates each GVK
 // to its corresponding string key in the swagger.Definitions map
 func (f *foapiv2) buildGvkIndex() error {
 	for did, dRef := range f.swagger.Definitions {
-		def, err := resolveSchemaRef(dRef, f.swagger.Definitions)
+		def, err := resolveSchemaRef2(dRef, f.swagger.Definitions)
 		if err != nil {
 			return err
 		}

manifest/openapi/foundry_v3.go

@@ -56,11 +56,11 @@ func (f *foapiv3) GetTypeByGVK(_ schema.GroupVersionKind) (tftypes.Type, map[str
 
 	sref := f.doc.Components.Schemas[""]
 
-	sch, err := resolveSchemaRef(sref, f.doc.Components.Schemas)
+	sch, err := resolveSchemaRef3(sref, f.doc.Components.Schemas)
 	if err != nil {
 		return nil, hints, fmt.Errorf("failed to resolve schema: %s", err)
 	}
 
-	tftype, err := getTypeFromSchema(sch, 50, &(f.typeCache), f.doc.Components.Schemas, ap, hints)
+	tftype, err := getTypeFromSchema3(sch, 50, &(f.typeCache), f.doc.Components.Schemas, ap, hints)
 	return tftype, hints, err
 }

manifest/openapi/schema_v2.go

@@ -0,0 +1,256 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package openapi
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/getkin/kin-openapi/openapi2"
+	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+	"github.com/hashicorp/terraform-provider-kubernetes/manifest"
+	"github.com/mitchellh/hashstructure"
+)
+
+func resolveSchemaRef2(ref *openapi2.SchemaRef, defs map[string]*openapi2.SchemaRef) (*openapi2.Schema, error) {
+	if ref.Value != nil {
+		return ref.Value, nil
+	}
+
+	rp := strings.Split(ref.Ref, "/")
+	sid := rp[len(rp)-1]
+
+	nref, ok := defs[sid]
+
+	if !ok {
+		return nil, errors.New("schema not found")
+	}
+	if nref == nil {
+		return nil, errors.New("nil schema reference")
+	}
+
+	// These are exceptional situations that require non-standard types.
+	switch sid {
+	case "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps":
+		t := openapi2.Schema{
+			Type: &openapi3.Types{""},
+		}
+		return &t, nil
+	case "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps":
+		t := openapi2.Schema{
+			Type: &openapi3.Types{""},
+		}
+		return &t, nil
+	}
+
+	return resolveSchemaRef2(nref, defs)
+}
+
+func getTypeFromSchema2(elem *openapi2.Schema, stackdepth uint64, typeCache *sync.Map, defs map[string]*openapi2.SchemaRef, ap tftypes.AttributePath, th map[string]string) (tftypes.Type, error) {
+	if stackdepth == 0 {
+		// this is a hack to overcome the inability to express recursion in tftypes
+		return nil, errors.New("recursion runaway while generating type from OpenAPI spec")
+	}
+
+	if elem == nil {
+		return nil, errors.New("cannot convert OpenAPI type (nil)")
+	}
+
+	h, herr := hashstructure.Hash(elem, nil)
+
+	var t tftypes.Type
+
+	// Check if attribute type is tagged as 'x-kubernetes-preserve-unknown-fields' in OpenAPI.
+	// If so, we add a type hint to indicate this and return DynamicPseudoType for this attribute,
+	// since we have no further structural information about it.
+	if xpufJSON, ok := elem.Extensions[manifest.PreserveUnknownFieldsLabel]; ok {
+		var xpuf bool
+		v, err := xpufJSON.(json.RawMessage).MarshalJSON()
+		if err == nil {
+			err = json.Unmarshal(v, &xpuf)
+			if err == nil && xpuf {
+				th[ap.String()] = manifest.PreserveUnknownFieldsLabel
+			}
+		}
+	}
+
+	// check if type is in cache
+	// HACK: this is temporarily disabled to diagnose a cache corruption issue.
+	// if herr == nil {
+	// 	if t, ok := typeCache.Load(h); ok {
+	// 		return t.(tftypes.Type), nil
+	// 	}
+	// }
+	switch {
+	case elem.Type.Is("string"):
+		if elem.Format == "int-or-string" {
+			th[ap.String()] = "io.k8s.apimachinery.pkg.util.intstr.IntOrString"
+		}
+		return tftypes.String, nil
+
+	case elem.Type.Is("boolean"):
+		return tftypes.Bool, nil
+
+	case elem.Type.Is("number"):
+		return tftypes.Number, nil
+
+	case elem.Type.Is("integer"):
+		return tftypes.Number, nil
+
+	case elem.Type.Is(""):
+		if xv, ok := elem.Extensions["x-kubernetes-int-or-string"]; ok {
+			xb, err := xv.(json.RawMessage).MarshalJSON()
+			if err != nil {
+				return tftypes.DynamicPseudoType, nil
+			}
+			var x bool
+			err = json.Unmarshal(xb, &x)
+			if err == nil && x {
+				th[ap.String()] = "io.k8s.apimachinery.pkg.util.intstr.IntOrString"
+				return tftypes.String, nil
+			}
+		}
+		return tftypes.DynamicPseudoType, nil // this is where DynamicType is set for when an attribute is tagged as 'x-kubernetes-preserve-unknown-fields'
+
+	case elem.Type.Is("array"):
+		switch {
+		case elem.Items != nil && elem.AdditionalProperties.Has == nil: // normal array - translates to a tftypes.List
+			it, err := resolveSchemaRef2(elem.Items, defs)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve schema for items: %s", err)
+			}
+			aap := ap.WithElementKeyInt(-1)
+			et, err := getTypeFromSchema2(it, stackdepth-1, typeCache, defs, *aap, th)
+			if err != nil {
+				return nil, err
+			}
+			if !isTypeFullyKnown(et) {
+				t = tftypes.Tuple{ElementTypes: []tftypes.Type{et}}
+			} else {
+				t = tftypes.List{ElementType: et}
+			}
+			if herr == nil {
+				typeCache.Store(h, t)
+			}
+			return t, nil
+		case elem.AdditionalProperties.Has != nil && *elem.AdditionalProperties.Has && elem.Items == nil: // "overriden" array - translates to a tftypes.Tuple
+			v2ref, err := schemaRefV3toV2(elem.AdditionalProperties.Schema)
+			if err != nil {
+				return nil, fmt.Errorf("failed to convert schema from v3 to v2: %s", err)
+			}
+			it, err := resolveSchemaRef2(v2ref, defs)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve schema for items: %s", err)
+			}
+			aap := ap.WithElementKeyInt(-1)
+			et, err := getTypeFromSchema2(it, stackdepth-1, typeCache, defs, *aap, th)
+			if err != nil {
+				return nil, err
+			}
+			t = tftypes.Tuple{ElementTypes: []tftypes.Type{et}}
+			return t, nil
+		}
+
+	case elem.Type.Is("object"):
+
+		switch {
+		case elem.Properties != nil && (elem.AdditionalProperties.Has == nil || !*elem.AdditionalProperties.Has):
+			// this is a standard OpenAPI object
+			atts := make(map[string]tftypes.Type, len(elem.Properties))
+			for p, v := range elem.Properties {
+				schema, err := resolveSchemaRef2(v, defs)
+				if err != nil {
+					return nil, fmt.Errorf("failed to resolve schema: %s", err)
+				}
+				aap := ap.WithAttributeName(p)
+				pType, err := getTypeFromSchema2(schema, stackdepth-1, typeCache, defs, *aap, th)
+				if err != nil {
+					return nil, err
+				}
+				atts[p] = pType
+			}
+			t = tftypes.Object{AttributeTypes: atts}
+			if herr == nil {
+				typeCache.Store(h, t)
+			}
+			return t, nil
+
+		case elem.Properties == nil && (elem.AdditionalProperties.Has != nil && *elem.AdditionalProperties.Has):
+			// this is how OpenAPI defines associative arrays
+			v2ref, err := schemaRefV3toV2(elem.AdditionalProperties.Schema)
+			if err != nil {
+				return nil, fmt.Errorf("failed to convert schema from v3 to v2: %s", err)
+			}
+			s, err := resolveSchemaRef2(v2ref, defs)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve schema: %s", err)
+			}
+			aap := ap.WithElementKeyString("#")
+			pt, err := getTypeFromSchema2(s, stackdepth-1, typeCache, defs, *aap, th)
+			if err != nil {
+				return nil, err
+			}
+			t = tftypes.Map{ElementType: pt}
+			if herr == nil {
+				typeCache.Store(h, t)
+			}
+			return t, nil
+
+		case elem.Properties == nil && (elem.AdditionalProperties.Has == nil || !*elem.AdditionalProperties.Has):
+			// this is a strange case, encountered with io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1 and also io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceStatus
+			t = tftypes.DynamicPseudoType
+			if herr == nil {
+				typeCache.Store(h, t)
+			}
+			return t, nil
+
+		}
+	}
+
+	return nil, fmt.Errorf("unknown type: %s", elem.Type)
+}
+
+func isTypeFullyKnown(t tftypes.Type) bool {
+	if t.Is(tftypes.DynamicPseudoType) {
+		return false
+	}
+	switch {
+	case t.Is(tftypes.Object{}):
+		for _, att := range t.(tftypes.Object).AttributeTypes {
+			if !isTypeFullyKnown(att) {
+				return false
+			}
+		}
+	case t.Is(tftypes.Tuple{}):
+		for _, ett := range t.(tftypes.Tuple).ElementTypes {
+			if !isTypeFullyKnown(ett) {
+				return false
+			}
+		}
+	case t.Is(tftypes.List{}):
+		return isTypeFullyKnown(t.(tftypes.List).ElementType)
+	case t.Is(tftypes.Set{}):
+		return isTypeFullyKnown(t.(tftypes.Set).ElementType)
+	case t.Is(tftypes.Map{}):
+		return isTypeFullyKnown(t.(tftypes.Map).ElementType)
+	}
+	return true
+}
+
+func schemaRefV3toV2(o *openapi3.SchemaRef) (*openapi2.SchemaRef, error) {
+	j, err := o.MarshalJSON()
+	if err != nil {
+		return nil, err
+	}
+	r := &openapi2.SchemaRef{}
+	err = r.UnmarshalJSON(j)
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}