technofab/zfs-localpv
1
0
Fork 0
mirror of https://github.com/TECHNOFAB11/zfs-localpv.git synced 2025-12-13 23:03:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

refact(deps): bump k8s and client-go deps to version v0.20.2 (#294)

Browse source 
Signed-off-by: prateekpandey14 <prateek.pandey@mayadata.io>
This commit is contained in:
Prateek Pandey 2021-03-31 16:43:42 +05:30 • committed by GitHub
parent 533e17a9aa
commit b1aa6ab51a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2196 changed files with 306727 additions and 251810 deletions
Download patch file Download diff file Expand all files Collapse all files

279
vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go generated vendored
View file

@ -18,6 +18,7 @@ package generators
import (
"bytes"
"encoding/json"
"fmt"
"io"
"path/filepath"
@ -29,7 +30,7 @@ import (
"k8s.io/gengo/namer"
"k8s.io/gengo/types"
"k8s.io/klog"
"k8s.io/klog/v2"
)
// CustomArgs is used tby the go2idl framework to pass args specific to this
@ -38,16 +39,45 @@ type CustomArgs struct {
ExtraPeerDirs []string // Always consider these as last-ditch possibilities for conversions.
}
var typeZeroValue = map[string]interface{}{
"uint": 0.,
"uint8": 0.,
"uint16": 0.,
"uint32": 0.,
"uint64": 0.,
"int": 0.,
"int8": 0.,
"int16": 0.,
"int32": 0.,
"int64": 0.,
"byte": 0,
"float64": 0.,
"float32": 0.,
"bool": false,
"time.Time": "",
"string": "",
"integer": 0.,
"number": 0.,
"boolean": false,
"[]byte": "", // base64 encoded characters
"interface{}": interface{}(nil),
}
// These are the comment tags that carry parameters for defaulter generation.
const tagName = "k8s:defaulter-gen"
const intputTagName = "k8s:defaulter-gen-input"
const inputTagName = "k8s:defaulter-gen-input"
const defaultTagName = "default"
func extractDefaultTag(comments []string) []string {
return types.ExtractCommentTags("+", comments)[defaultTagName]
}
func extractTag(comments []string) []string {
return types.ExtractCommentTags("+", comments)[tagName]
}
func extractInputTag(comments []string) []string {
return types.ExtractCommentTags("+", comments)[intputTagName]
return types.ExtractCommentTags("+", comments)[inputTagName]
}
func checkTag(comments []string, require ...string) bool {
@ -248,7 +278,11 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
shouldCreateObjectDefaulterFn := func(t *types.Type) bool {
if defaults, ok := existingDefaulters[t]; ok && defaults.object != nil {
// A default generator is defined
klog.V(5).Infof(" an object defaulter already exists as %s", defaults.base.Name)
baseTypeName := "<unknown>"
if defaults.base != nil {
baseTypeName = defaults.base.Name.String()
}
klog.V(5).Infof(" an object defaulter already exists as %s", baseTypeName)
return false
}
// opt-out
@ -397,6 +431,112 @@ func newCallTreeForType(existingDefaulters, newDefaulters defaulterFuncMap) *cal
}
}
func resolveTypeAndDepth(t *types.Type) (*types.Type, int) {
var prev *types.Type
depth := 0
for prev != t {
prev = t
if t.Kind == types.Alias {
t = t.Underlying
} else if t.Kind == types.Pointer {
t = t.Elem
depth += 1
}
}
return t, depth
}
// getNestedDefault returns the first default value when resolving alias types
func getNestedDefault(t *types.Type) string {
var prev *types.Type
for prev != t {
prev = t
defaultMap := extractDefaultTag(t.CommentLines)
if len(defaultMap) == 1 && defaultMap[0] != "" {
return defaultMap[0]
}
if t.Kind == types.Alias {
t = t.Underlying
} else if t.Kind == types.Pointer {
t = t.Elem
}
}
return ""
}
func mustEnforceDefault(t *types.Type, depth int, omitEmpty bool) (interface{}, error) {
if depth > 0 {
return nil, nil
}
switch t.Kind {
case types.Pointer, types.Map, types.Slice, types.Array, types.Interface:
return nil, nil
case types.Struct:
return map[string]interface{}{}, nil
case types.Builtin:
if !omitEmpty {
if zero, ok := typeZeroValue[t.String()]; ok {
return zero, nil
} else {
return nil, fmt.Errorf("please add type %v to typeZeroValue struct", t)
}
}
return nil, nil
default:
return nil, fmt.Errorf("not sure how to enforce default for %v", t.Kind)
}
}
func populateDefaultValue(node *callNode, t *types.Type, tags string, commentLines []string) *callNode {
defaultMap := extractDefaultTag(commentLines)
var defaultString string
if len(defaultMap) == 1 {
defaultString = defaultMap[0]
}
t, depth := resolveTypeAndDepth(t)
if depth > 0 && defaultString == "" {
defaultString = getNestedDefault(t)
}
if len(defaultMap) > 1 {
klog.Fatalf("Found more than one default tag for %v", t.Kind)
} else if len(defaultMap) == 0 {
return node
}
var defaultValue interface{}
if err := json.Unmarshal([]byte(defaultString), &defaultValue); err != nil {
klog.Fatalf("Failed to unmarshal default: %v", err)
}
omitEmpty := strings.Contains(reflect.StructTag(tags).Get("json"), "omitempty")
if enforced, err := mustEnforceDefault(t, depth, omitEmpty); err != nil {
klog.Fatal(err)
} else if enforced != nil {
if defaultValue != nil {
if reflect.DeepEqual(defaultValue, enforced) {
// If the default value annotation matches the default value for the type,
// do not generate any defaulting function
return node
} else {
enforcedJSON, _ := json.Marshal(enforced)
klog.Fatalf("Invalid default value (%#v) for non-pointer/non-omitempty. If specified, must be: %v", defaultValue, string(enforcedJSON))
}
}
}
// callNodes are not automatically generated for primitive types. Generate one if the callNode does not exist
if node == nil {
node = &callNode{}
node.markerOnly = true
}
node.defaultIsPrimitive = t.IsPrimitive()
node.defaultType = t.String()
node.defaultValue = defaultString
node.defaultDepth = depth
return node
}
// build creates a tree of paths to fields (based on how they would be accessed in Go - pointer, elem,
// slice, or key) and the functions that should be invoked on each field. An in-order traversal of the resulting tree
// can be used to generate a Go function that invokes each nested function on the appropriate type. The return
@ -469,12 +609,19 @@ func (c *callTreeForType) build(t *types.Type, root bool) *callNode {
child.elem = true
}
parent.children = append(parent.children, *child)
} else if member := populateDefaultValue(nil, t.Elem, "", t.Elem.CommentLines); member != nil {
member.index = true
parent.children = append(parent.children, *member)
}
case types.Map:
if child := c.build(t.Elem, false); child != nil {
child.key = true
parent.children = append(parent.children, *child)
} else if member := populateDefaultValue(nil, t.Elem, "", t.Elem.CommentLines); member != nil {
member.key = true
parent.children = append(parent.children, *member)
}
case types.Struct:
for _, field := range t.Members {
name := field.Name
@ -487,7 +634,11 @@ func (c *callTreeForType) build(t *types.Type, root bool) *callNode {
}
if child := c.build(field.Type, false); child != nil {
child.field = name
populateDefaultValue(child, field.Type, field.Tags, field.CommentLines)
parent.children = append(parent.children, *child)
} else if member := populateDefaultValue(nil, field.Type, field.Tags, field.CommentLines); member != nil {
member.field = name
parent.children = append(parent.children, *member)
}
}
case types.Alias:
@ -672,6 +823,27 @@ type callNode struct {
call []*types.Type
// children is the child call nodes that must also be traversed
children []callNode
// defaultValue is the defaultValue of a callNode struct
// Only primitive types and pointer types are eligible to have a default value
defaultValue string
// defaultIsPrimitive is used to determine how to assign the default value.
// Primitive types will be directly assigned while complex types will use JSON unmarshalling
defaultIsPrimitive bool
// markerOnly is true if the callNode exists solely to fill in a default value
markerOnly bool
// defaultDepth is used to determine pointer level of the default value
// For example 1 corresponds to setting a default value and taking its pointer while
// 2 corresponds to setting a default value and taking its pointer's pointer
// 0 implies that no pointers are used
defaultDepth int
// defaultType is the type of the default value.
// Only populated if defaultIsPrimitive is true
defaultType string
}
// CallNodeVisitorFunc is a function for visiting a call tree. ancestors is the list of all parents
@ -727,6 +899,85 @@ func (n *callNode) writeCalls(varName string, isVarPointer bool, sw *generator.S
}
}
func (n *callNode) writeDefaulter(varName string, index string, isVarPointer bool, sw *generator.SnippetWriter) {
if n.defaultValue == "" {
return
}
varPointer := varName
if !isVarPointer {
varPointer = "&" + varPointer
}
args := generator.Args{
"defaultValue": n.defaultValue,
"varPointer": varPointer,
"varName": varName,
"index": index,
"varDepth": n.defaultDepth,
"varType": n.defaultType,
}
if n.index {
sw.Do("if reflect.ValueOf($.var$[$.index$]).IsZero() {\n", generator.Args{"var": varName, "index": index})
if n.defaultIsPrimitive {
if n.defaultDepth > 0 {
sw.Do("var ptrVar$.varDepth$ $.varType$ = $.defaultValue$\n", args)
for i := n.defaultDepth; i > 0; i-- {
sw.Do("ptrVar$.ptri$ := &ptrVar$.i$\n", generator.Args{"i": fmt.Sprintf("%d", i), "ptri": fmt.Sprintf("%d", (i - 1))})
}
sw.Do("$.varName$[$.index$] = ptrVar0", args)
} else {
sw.Do("$.varName$[$.index$] = $.defaultValue$", args)
}
} else {
sw.Do("if err := json.Unmarshal([]byte(`$.defaultValue$`), $.varPointer$[$.index$]); err != nil {\n", args)
sw.Do("panic(err)\n", nil)
sw.Do("}\n", nil)
}
} else if n.key {
mapDefaultVar := index + "_default"
args["mapDefaultVar"] = mapDefaultVar
sw.Do("if reflect.ValueOf($.var$[$.index$]).IsZero() {\n", generator.Args{"var": varName, "index": index})
if n.defaultIsPrimitive {
if n.defaultDepth > 0 {
sw.Do("var ptrVar$.varDepth$ $.varType$ = $.defaultValue$\n", args)
for i := n.defaultDepth; i > 0; i-- {
sw.Do("ptrVar$.ptri$ := &ptrVar$.i$\n", generator.Args{"i": fmt.Sprintf("%d", i), "ptri": fmt.Sprintf("%d", (i - 1))})
}
sw.Do("$.varName$[$.index$] = ptrVar0", args)
} else {
sw.Do("$.varName$[$.index$] = $.defaultValue$", args)
}
} else {
sw.Do("$.mapDefaultVar$ := $.varName$[$.index$]\n", args)
sw.Do("if err := json.Unmarshal([]byte(`$.defaultValue$`), &$.mapDefaultVar$); err != nil {\n", args)
sw.Do("panic(err)\n", nil)
sw.Do("}\n", nil)
sw.Do("$.varName$[$.index$] = $.mapDefaultVar$\n", args)
}
} else {
sw.Do("if reflect.ValueOf($.var$).IsZero() {\n", generator.Args{"var": varName})
if n.defaultIsPrimitive {
if n.defaultDepth > 0 {
sw.Do("var ptrVar$.varDepth$ $.varType$ = $.defaultValue$\n", args)
for i := n.defaultDepth; i > 0; i-- {
sw.Do("ptrVar$.ptri$ := &ptrVar$.i$\n", generator.Args{"i": fmt.Sprintf("%d", i), "ptri": fmt.Sprintf("%d", (i - 1))})
}
sw.Do("$.varName$ = ptrVar0", args)
} else {
sw.Do("$.varName$ = $.defaultValue$", args)
}
} else {
sw.Do("if err := json.Unmarshal([]byte(`$.defaultValue$`), $.varPointer$); err != nil {\n", args)
sw.Do("panic(err)\n", nil)
sw.Do("}\n", nil)
}
}
sw.Do("}\n", nil)
}
// WriteMethod performs an in-order traversal of the calltree, generating loops and if blocks as necessary
// to correctly turn the call tree into a method body that invokes all calls on all child nodes of the call tree.
// Depth is used to generate local variables at the proper depth.
@ -754,19 +1005,31 @@ func (n *callNode) WriteMethod(varName string, depth int, ancestors []*callNode,
switch {
case n.index:
sw.Do("for $.index$ := range $.var$ {\n", vars)
if n.elem {
sw.Do("$.local$ := $.var$[$.index$]\n", vars)
} else {
sw.Do("$.local$ := &$.var$[$.index$]\n", vars)
if !n.markerOnly {
if n.elem {
sw.Do("$.local$ := $.var$[$.index$]\n", vars)
} else {
sw.Do("$.local$ := &$.var$[$.index$]\n", vars)
}
}
n.writeDefaulter(varName, index, isPointer, sw)
n.writeCalls(local, true, sw)
for i := range n.children {
n.children[i].WriteMethod(local, depth+1, append(ancestors, n), sw)
}
sw.Do("}\n", nil)
case n.key:
if n.defaultValue != "" {
// Map keys are typed and cannot share the same index variable as arrays and other maps
index = index + "_" + ancestors[len(ancestors)-1].field
vars["index"] = index
sw.Do("for $.index$ := range $.var$ {\n", vars)
n.writeDefaulter(varName, index, isPointer, sw)
sw.Do("}\n", nil)
}
default:
n.writeDefaulter(varName, index, isPointer, sw)
n.writeCalls(varName, isPointer, sw)
for i := range n.children {
n.children[i].WriteMethod(varName, depth, append(ancestors, n), sw)