Convert numbers like Kubernetes does for json.Marshaler types

Author: jpbetz

value/reflectcache.go

@@ -210,23 +210,23 @@ func (e TypeReflectCacheEntry) ToUnstructured(sv reflect.Value) (interface{}, er
 
 		case data[0] == '"':
 			var result string
-			err := json.Unmarshal(data, &result)
+			err := Unmarshal(data, &result)
 			if err != nil {
 				return nil, fmt.Errorf("error decoding string from json: %v", err)
 			}
 			return result, nil
 
 		case data[0] == '{':
 			result := make(map[string]interface{})
-			err := json.Unmarshal(data, &result)
+			err := Unmarshal(data, &result)
 			if err != nil {
 				return nil, fmt.Errorf("error decoding object from json: %v", err)
 			}
 			return result, nil
 
 		case data[0] == '[':
 			result := make([]interface{}, 0)
-			err := json.Unmarshal(data, &result)
+			err := Unmarshal(data, &result)
 			if err != nil {
 				return nil, fmt.Errorf("error decoding array from json: %v", err)
 			}
@@ -238,9 +238,9 @@ func (e TypeReflectCacheEntry) ToUnstructured(sv reflect.Value) (interface{}, er
 				resultFloat float64
 				err         error
 			)
-			if err = json.Unmarshal(data, &resultInt); err == nil {
+			if err = Unmarshal(data, &resultInt); err == nil {
 				return resultInt, nil
-			} else if err = json.Unmarshal(data, &resultFloat); err == nil {
+			} else if err = Unmarshal(data, &resultFloat); err == nil {
 				return resultFloat, nil
 			} else {
 				return nil, fmt.Errorf("error decoding number from json: %v", err)
@@ -363,3 +363,101 @@ func (c *typeReflectCache) update(updates reflectCacheMap) {
 	}
 	c.value.Store(newCacheMap)
 }
+
+// Below json Unmarshal is fromk8s.io/apimachinery/pkg/util/json
+// to handle number conversions as expected by Kubernetes
+
+// limit recursive depth to prevent stack overflow errors
+const maxDepth = 10000
+
+// Unmarshal unmarshals the given data
+// If v is a *map[string]interface{}, numbers are converted to int64 or float64
+func Unmarshal(data []byte, v interface{}) error {
+	switch v := v.(type) {
+	case *map[string]interface{}:
+		// Build a decoder from the given data
+		decoder := json.NewDecoder(bytes.NewBuffer(data))
+		// Preserve numbers, rather than casting to float64 automatically
+		decoder.UseNumber()
+		// Run the decode
+		if err := decoder.Decode(v); err != nil {
+			return err
+		}
+		// If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64
+		return convertMapNumbers(*v, 0)
+
+	case *[]interface{}:
+		// Build a decoder from the given data
+		decoder := json.NewDecoder(bytes.NewBuffer(data))
+		// Preserve numbers, rather than casting to float64 automatically
+		decoder.UseNumber()
+		// Run the decode
+		if err := decoder.Decode(v); err != nil {
+			return err
+		}
+		// If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64
+		return convertSliceNumbers(*v, 0)
+
+	default:
+		return json.Unmarshal(data, v)
+	}
+}
+
+// convertMapNumbers traverses the map, converting any json.Number values to int64 or float64.
+// values which are map[string]interface{} or []interface{} are recursively visited
+func convertMapNumbers(m map[string]interface{}, depth int) error {
+	if depth > maxDepth {
+		return fmt.Errorf("exceeded max depth of %d", maxDepth)
+	}
+
+	var err error
+	for k, v := range m {
+		switch v := v.(type) {
+		case json.Number:
+			m[k], err = convertNumber(v)
+		case map[string]interface{}:
+			err = convertMapNumbers(v, depth+1)
+		case []interface{}:
+			err = convertSliceNumbers(v, depth+1)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// convertSliceNumbers traverses the slice, converting any json.Number values to int64 or float64.
+// values which are map[string]interface{} or []interface{} are recursively visited
+func convertSliceNumbers(s []interface{}, depth int) error {
+	if depth > maxDepth {
+		return fmt.Errorf("exceeded max depth of %d", maxDepth)
+	}
+
+	var err error
+	for i, v := range s {
+		switch v := v.(type) {
+		case json.Number:
+			s[i], err = convertNumber(v)
+		case map[string]interface{}:
+			err = convertMapNumbers(v, depth+1)
+		case []interface{}:
+			err = convertSliceNumbers(v, depth+1)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// convertNumber converts a json.Number to an int64 or float64, or returns an error
+func convertNumber(n json.Number) (interface{}, error) {
+	// Attempt to convert to an int64 first
+	if i, err := n.Int64(); err == nil {
+		return i, nil
+	}
+	// Return a float64 (default json.Decode() behavior)
+	// An overflow will return an error
+	return n.Float64()
+}