Merge pull request #1 from alexsomesan/cache_stackdepth

Exception for JSONSchemaProps / partial type cache / limit recursion depth

Author: alexsomesan

foundry/foundry.go

@@ -4,11 +4,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log"
 	"strings"
 
 	"github.com/getkin/kin-openapi/openapi2"
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/hashicorp/go-cty/cty"
+	"github.com/mitchellh/hashstructure"
 )
 
 // NewFoundryFromSpecV2 creates a new cty.Type foundry from an OpenAPI v2 spec document
@@ -24,7 +26,11 @@ func NewFoundryFromSpecV2(spec []byte) (Foundry, error) {
 		return nil, fmt.Errorf("failed to parse spec: %s", err)
 	}
 
-	f := foapiv2{&swg}
+	f := foapiv2{
+		swagger:        &swg,
+		typeCache:      make(map[uint64]cty.Type),
+		recursionDepth: 50, // arbitrarily large number - a type this big will likely kill Terraform anyway
+	}
 	d := f.swagger.Definitions
 	if d == nil || len(d) == 0 {
 		return nil, errors.New("spec has no type information")
@@ -39,7 +45,9 @@ type Foundry interface {
 }
 
 type foapiv2 struct {
-	swagger *openapi2.Swagger
+	swagger        *openapi2.Swagger
+	typeCache      map[uint64]cty.Type
+	recursionDepth uint64
 }
 
 // GetTypeById looks up a type by its fully qualified ID in the Definitions sections of
@@ -60,7 +68,7 @@ func (f foapiv2) GetTypeByID(id string) (cty.Type, error) {
 		return cty.NilType, fmt.Errorf("failed to resolve schema: %s", err)
 	}
 
-	return f.getTypeFromSchema(sch)
+	return f.getTypeFromSchema(sch, 0)
 }
 
 func (f foapiv2) resolveSchemaRef(ref *openapi3.SchemaRef) (*openapi3.Schema, error) {
@@ -77,6 +85,11 @@ func (f foapiv2) resolveSchemaRef(ref *openapi3.SchemaRef) (*openapi3.Schema, er
 			Type: "integer",
 		}
 		return &t, nil
+	case "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.JSONSchemaProps":
+		t := openapi3.Schema{
+			Type: "",
+		}
+		return &t, nil
 	}
 
 	nref, ok := f.swagger.Definitions[sid]
@@ -91,10 +104,27 @@ func (f foapiv2) resolveSchemaRef(ref *openapi3.SchemaRef) (*openapi3.Schema, er
 	return f.resolveSchemaRef(nref)
 }
 
-func (f foapiv2) getTypeFromSchema(elem *openapi3.Schema) (cty.Type, error) {
+func (f foapiv2) getTypeFromSchema(elem *openapi3.Schema, stackdepth uint64) (cty.Type, error) {
+	if stackdepth > f.recursionDepth {
+		log.Println("at stack depth")
+		// this is a hack to overcome the inability to express recursion in cty
+		return cty.DynamicPseudoType, nil
+	}
+	log.Printf("stack depth: %d\n", stackdepth)
+
 	if elem == nil {
 		return cty.NilType, errors.New("nil type")
 	}
+	h, herr := hashstructure.Hash(elem, nil)
+
+	var t cty.Type
+
+	// check if type is in cache
+	if herr == nil {
+		if t, ok := f.typeCache[h]; ok {
+			return t, nil
+		}
+	}
 
 	switch elem.Type {
 
@@ -109,29 +139,41 @@ func (f foapiv2) getTypeFromSchema(elem *openapi3.Schema) (cty.Type, error) {
 				if err != nil {
 					return cty.NilType, fmt.Errorf("failed to resolve schema: %s", err)
 				}
-				pType, err := f.getTypeFromSchema(schema)
+				pType, err := f.getTypeFromSchema(schema, stackdepth+1)
 				if err != nil {
 					return cty.NilType, err
 				}
 				atts[p] = pType
 			}
-			return cty.Object(atts), nil
+			t = cty.Object(atts)
+			if herr == nil {
+				f.typeCache[h] = t
+			}
+			return t, nil
 
 		case elem.Properties == nil && elem.AdditionalProperties != nil:
 			// this is how OpenAPI defines associative arrays
 			s, err := f.resolveSchemaRef(elem.AdditionalProperties)
 			if err != nil {
 				return cty.NilType, fmt.Errorf("failed to resolve schema: %s", err)
 			}
-			pt, err := f.getTypeFromSchema(s)
+			pt, err := f.getTypeFromSchema(s, stackdepth+1)
 			if err != nil {
 				return cty.NilType, err
 			}
-			return cty.Map(pt), nil
+			t = cty.Map(pt)
+			if herr == nil {
+				f.typeCache[h] = t
+			}
+			return t, nil
 
 		case elem.Properties == nil && elem.AdditionalProperties == nil:
 			// this is a strange case, encountered with io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1
-			return cty.DynamicPseudoType, nil
+			t = cty.DynamicPseudoType
+			if herr == nil {
+				f.typeCache[h] = t
+			}
+			return t, nil
 
 		}
 
@@ -140,11 +182,15 @@ func (f foapiv2) getTypeFromSchema(elem *openapi3.Schema) (cty.Type, error) {
 		if err != nil {
 			return cty.NilType, fmt.Errorf("failed to resolve schema for items: %s", err)
 		}
-		t, err := f.getTypeFromSchema(it)
+		t, err := f.getTypeFromSchema(it, stackdepth+1)
 		if err != nil {
 			return cty.NilType, err
 		}
-		return cty.List(t), nil
+		t = cty.List(t)
+		if herr == nil {
+			f.typeCache[h] = t
+		}
+		return t, nil
 
 	case "string":
 		return cty.String, nil

go.mod

@@ -6,4 +6,5 @@ require (
 	github.com/davecgh/go-spew v1.1.1
 	github.com/getkin/kin-openapi v0.4.0
 	github.com/hashicorp/go-cty v1.4.1-0.20200414143053-d3edf31b6320
+	github.com/mitchellh/hashstructure v1.0.0
 )

go.sum

@@ -16,6 +16,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mitchellh/hashstructure v1.0.0 h1:ZkRJX1CyOoTkar7p/mLS5TZU4nJ1Rn/F8u9dGS02Q3Y=
+github.com/mitchellh/hashstructure v1.0.0/go.mod h1:QjSHrPWS+BGUVBYkbTZWEnOh3G1DutKwClXU/ABz6AQ=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=