Merge pull request #136 from jpbetz/value-reflector

Add reflector based implementation of value interface

Author: k8s-ci-robot

.gitignore

@@ -0,0 +1 @@
+.idea

typed/merge.go

@@ -328,8 +328,7 @@ func (w *mergingWalker) visitMapItems(t *schema.Map, lhs, rhs value.Map) (errs V
 	if rhs != nil {
 		rhs.Iterate(func(key string, val value.Value) bool {
 			if lhs != nil {
-				if v, ok := lhs.Get(key); ok {
-					v.Recycle()
+				if lhs.Has(key) {
 					return true
 				}
 			}

typed/parser.go

@@ -102,12 +102,29 @@ func (p ParseableType) FromYAML(object YAMLObject) (*TypedValue, error) {
 	return AsTyped(value.NewValueInterface(v), p.Schema, p.TypeRef)
 }
 
-// FromUnstructured converts a go interface to a TypedValue. It will return an
+// FromUnstructured converts a go "interface{}" type, typically an
+// unstructured object in Kubernetes world, to a TypedValue. It returns an
 // error if the resulting object fails schema validation.
+// The provided interface{} must be one of: map[string]interface{},
+// map[interface{}]interface{}, []interface{}, int types, float types,
+// string or boolean. Nested interface{} must also be one of these types.
 func (p ParseableType) FromUnstructured(in interface{}) (*TypedValue, error) {
 	return AsTyped(value.NewValueInterface(in), p.Schema, p.TypeRef)
 }
 
+// FromStructured converts a go "interface{}" type, typically an structured object in
+// Kubernetes, to a TypedValue. It will return an error if the resulting object fails
+// schema validation. The provided "interface{}" value must be a pointer so that the
+// value can be modified via reflection. The provided "interface{}" may contain structs
+// and types that are converted to Values by the jsonMarshaler interface.
+func (p ParseableType) FromStructured(in interface{}) (*TypedValue, error) {
+	v, err := value.NewValueReflect(in)
+	if err != nil {
+		return nil, fmt.Errorf("error creating struct value reflector: %v", err)
+	}
+	return AsTyped(v, p.Schema, p.TypeRef)
+}
+
 // DeducedParseableType is a ParseableType that deduces the type from
 // the content of the object.
 var DeducedParseableType ParseableType = createOrDie(YAMLObject(`types:

typed/union.go

@@ -243,7 +243,7 @@ func (u *union) Normalize(old, new, out value.Map) error {
 		return fmt.Errorf("multiple fields set without discriminator change: %v", ns)
 	}
 
-	// Update discriminiator if it needs to be deduced.
+	// Set discriminiator if it needs to be deduced.
 	if u.deduceInvalidDiscriminator && len(ns) == 1 {
 		u.d.Set(out, u.dn.toDiscriminated(*ns.One()))
 	}

typed/validate_test.go

@@ -288,3 +288,98 @@ func TestSchemaSchema(t *testing.T) {
 		t.Fatalf("failed to create schemaschema: %v", err)
 	}
 }
+
+func BenchmarkValidateStructured(b *testing.B) {
+	type Primitives struct {
+		s string
+		i int64
+		f float64
+		b bool
+	}
+
+	primitive1 := Primitives{s: "string1"}
+	primitive2 := Primitives{i: 100}
+	primitive3 := Primitives{f: 3.14}
+	primitive4 := Primitives{b: true}
+
+	type Example struct {
+		listOfPrimitives []Primitives
+		mapOfPrimitives  map[string]Primitives
+		mapOfLists       map[string][]Primitives
+	}
+
+	tests := []struct {
+		name         string
+		rootTypeName string
+		schema       typed.YAMLObject
+		object       interface{}
+	}{
+		{
+			name:         "struct",
+			rootTypeName: "example",
+			schema: `types:
+- name: example
+  map:
+    fields:
+    - name: listOfPrimitives
+      type:
+        list:
+          elementType:
+            namedType: primitives
+    - name: mapOfPrimitives
+      type:
+        map:
+          elementType:
+            namedType: primitives
+    - name: mapOfLists
+      type:
+        map:
+          elementType:
+            list:
+              elementType:
+                namedType: primitives
+- name: primitives
+  map:
+    fields:
+    - name: s
+      type:
+        scalar: string
+    - name: i
+      type:
+        scalar: numeric
+    - name: f
+      type:
+        scalar: numeric
+    - name: b
+      type:
+        scalar: boolean
+`,
+			object: &Example{
+				listOfPrimitives: []Primitives{primitive1, primitive2, primitive3, primitive4},
+				mapOfPrimitives:  map[string]Primitives{"1": primitive1, "2": primitive2, "3": primitive3, "4": primitive4},
+				mapOfLists: map[string][]Primitives{
+					"1": {primitive1, primitive2, primitive3, primitive4},
+					"2": {primitive1, primitive2, primitive3, primitive4},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		b.Run(test.name, func(b *testing.B) {
+			parser, err := typed.NewParser(test.schema)
+			if err != nil {
+				b.Fatalf("failed to create schema: %v", err)
+			}
+			pt := parser.Type(test.rootTypeName)
+
+			b.ReportAllocs()
+			for n := 0; n < b.N; n++ {
+				tv, err := pt.FromStructured(test.object)
+				if err != nil {
+					b.Errorf("failed to parse/validate yaml: %v\n%v", err, tv)
+				}
+			}
+		})
+	}
+}

value/fields.go

@@ -27,7 +27,7 @@ type Field struct {
 	Value Value
 }
 
-// FieldList is a list of key-value pairs. Each field is expected to
+// FieldList is a list of key-value pairs. Each field is expectUpdated to
 // have a different name.
 type FieldList []Field
 

value/jsontagutil.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package value
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// TODO: This implements the same functionality as https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/runtime/converter.go#L236
+// but is based on the highly efficient approach from https://golang.org/src/encoding/json/encode.go
+
+func lookupJsonTags(f reflect.StructField) (name string, omit bool, inline bool, omitempty bool) {
+	tag := f.Tag.Get("json")
+	if tag == "-" {
+		return "", true, false, false
+	}
+	name, opts := parseTag(tag)
+	if name == "" {
+		name = f.Name
+	}
+	return name, false, opts.Contains("inline"), opts.Contains("omitempty")
+}
+
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Ptr:
+		return v.IsNil()
+	case reflect.Chan, reflect.Func:
+		panic(fmt.Sprintf("unsupported type: %v", v.Type()))
+	}
+	return false
+}
+
+type tagOptions string
+
+// parseTag splits a struct field's json tag into its name and
+// comma-separated options.
+func parseTag(tag string) (string, tagOptions) {
+	if idx := strings.Index(tag, ","); idx != -1 {
+		return tag[:idx], tagOptions(tag[idx+1:])
+	}
+	return tag, tagOptions("")
+}
+
+// Contains reports whether a comma-separated list of options
+// contains a particular substr flag. substr must be surrounded by a
+// string boundary or commas.
+func (o tagOptions) Contains(optionName string) bool {
+	if len(o) == 0 {
+		return false
+	}
+	s := string(o)
+	for s != "" {
+		var next string
+		i := strings.Index(s, ",")
+		if i >= 0 {
+			s, next = s[:i], s[i+1:]
+		}
+		if s == optionName {
+			return true
+		}
+		s = next
+	}
+	return false
+}

value/listreflect.go

@@ -0,0 +1,42 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package value
+
+import "reflect"
+
+type listReflect struct {
+	Value reflect.Value
+}
+
+func (r listReflect) Length() int {
+	val := r.Value
+	return val.Len()
+}
+
+func (r listReflect) At(i int) Value {
+	val := r.Value
+	return mustWrapValueReflect(val.Index(i))
+}
+
+func (r listReflect) Unstructured() interface{} {
+	l := r.Length()
+	result := make([]interface{}, l)
+	for i := 0; i < l; i++ {
+		result[i] = r.At(i).Unstructured()
+	}
+	return result
+}

value/map.go

@@ -27,6 +27,8 @@ type Map interface {
 	Set(key string, val Value)
 	// Get returns the value for the given key, if present, or (nil, false) otherwise.
 	Get(key string) (Value, bool)
+	// Has returns true if the key is present, or false otherwise.
+	Has(key string) bool
 	// Delete removes the key from the map.
 	Delete(key string)
 	// Equals compares the two maps, and return true if they are the same, false otherwise.