rebase: update kubernetes to v1.20.0

updated kubernetes packages to latest
release.

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/k8s.io/apimachinery/pkg/labels/labels.go

@@ -57,14 +57,22 @@ func (ls Set) Get(label string) string {
 	return ls[label]
 }
 
-// AsSelector converts labels into a selectors.
+// AsSelector converts labels into a selectors. It does not
+// perform any validation, which means the server will reject
+// the request if the Set contains invalid values.
 func (ls Set) AsSelector() Selector {
 	return SelectorFromSet(ls)
 }
 
+// AsValidatedSelector converts labels into a selectors.
+// The Set is validated client-side, which allows to catch errors early.
+func (ls Set) AsValidatedSelector() (Selector, error) {
+	return ValidatedSelectorFromSet(ls)
+}
+
 // AsSelectorPreValidated converts labels into a selector, but
-// assumes that labels are already validated and thus don't
-// preform any validation.
+// assumes that labels are already validated and thus doesn't
+// perform any validation.
 // According to our measurements this is significantly faster
 // in codepaths that matter at high scale.
 func (ls Set) AsSelectorPreValidated() Selector {
@@ -133,25 +141,6 @@ func Equals(labels1, labels2 Set) bool {
 	return true
 }
 
-// AreLabelsInWhiteList verifies if the provided label list
-// is in the provided whitelist and returns true, otherwise false.
-func AreLabelsInWhiteList(labels, whitelist Set) bool {
-	if len(whitelist) == 0 {
-		return true
-	}
-
-	for k, v := range labels {
-		value, ok := whitelist[k]
-		if !ok {
-			return false
-		}
-		if value != v {
-			return false
-		}
-	}
-	return true
-}
-
 // ConvertSelectorToLabelsMap converts selector string to labels map
 // and validates keys and values
 func ConvertSelectorToLabelsMap(selector string) (Set, error) {

vendor/k8s.io/apimachinery/pkg/labels/selector.go

@@ -26,7 +26,7 @@ import (
 	"k8s.io/apimachinery/pkg/selection"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/validation"
-	"k8s.io/klog"
+	"k8s.io/klog/v2"
 )
 
 // Requirements is AND of all requirements.
@@ -68,13 +68,15 @@ func Everything() Selector {
 
 type nothingSelector struct{}
 
-func (n nothingSelector) Matches(_ Labels) bool                                      { return false }
-func (n nothingSelector) Empty() bool                                                { return false }
-func (n nothingSelector) String() string                                             { return "" }
-func (n nothingSelector) Add(_ ...Requirement) Selector                              { return n }
-func (n nothingSelector) Requirements() (Requirements, bool)                         { return nil, false }
-func (n nothingSelector) DeepCopySelector() Selector                                 { return n }
-func (n nothingSelector) RequiresExactMatch(label string) (value string, found bool) { return "", false }
+func (n nothingSelector) Matches(_ Labels) bool              { return false }
+func (n nothingSelector) Empty() bool                        { return false }
+func (n nothingSelector) String() string                     { return "" }
+func (n nothingSelector) Add(_ ...Requirement) Selector      { return n }
+func (n nothingSelector) Requirements() (Requirements, bool) { return nil, false }
+func (n nothingSelector) DeepCopySelector() Selector         { return n }
+func (n nothingSelector) RequiresExactMatch(label string) (value string, found bool) {
+	return "", false
+}
 
 // Nothing returns a selector that matches no labels
 func Nothing() Selector {
@@ -221,7 +223,7 @@ func (r *Requirement) Matches(ls Labels) bool {
 			return false
 		}
 
-		// There should be only one strValue in r.strValues, and can be converted to a integer.
+		// There should be only one strValue in r.strValues, and can be converted to an integer.
 		if len(r.strValues) != 1 {
 			klog.V(10).Infof("Invalid values count %+v of requirement %#v, for 'Gt', 'Lt' operators, exactly one value is required", len(r.strValues), r)
 			return false
@@ -261,11 +263,11 @@ func (r *Requirement) Values() sets.String {
 }
 
 // Empty returns true if the internalSelector doesn't restrict selection space
-func (lsel internalSelector) Empty() bool {
-	if lsel == nil {
+func (s internalSelector) Empty() bool {
+	if s == nil {
 		return true
 	}
-	return len(lsel) == 0
+	return len(s) == 0
 }
 
 // String returns a human-readable string that represents this
@@ -328,51 +330,51 @@ func safeSort(in []string) []string {
 }
 
 // Add adds requirements to the selector. It copies the current selector returning a new one
-func (lsel internalSelector) Add(reqs ...Requirement) Selector {
-	var sel internalSelector
-	for ix := range lsel {
-		sel = append(sel, lsel[ix])
+func (s internalSelector) Add(reqs ...Requirement) Selector {
+	var ret internalSelector
+	for ix := range s {
+		ret = append(ret, s[ix])
 	}
 	for _, r := range reqs {
-		sel = append(sel, r)
+		ret = append(ret, r)
 	}
-	sort.Sort(ByKey(sel))
-	return sel
+	sort.Sort(ByKey(ret))
+	return ret
 }
 
 // Matches for a internalSelector returns true if all
 // its Requirements match the input Labels. If any
 // Requirement does not match, false is returned.
-func (lsel internalSelector) Matches(l Labels) bool {
-	for ix := range lsel {
-		if matches := lsel[ix].Matches(l); !matches {
+func (s internalSelector) Matches(l Labels) bool {
+	for ix := range s {
+		if matches := s[ix].Matches(l); !matches {
 			return false
 		}
 	}
 	return true
 }
 
-func (lsel internalSelector) Requirements() (Requirements, bool) { return Requirements(lsel), true }
+func (s internalSelector) Requirements() (Requirements, bool) { return Requirements(s), true }
 
 // String returns a comma-separated string of all
 // the internalSelector Requirements' human-readable strings.
-func (lsel internalSelector) String() string {
+func (s internalSelector) String() string {
 	var reqs []string
-	for ix := range lsel {
-		reqs = append(reqs, lsel[ix].String())
+	for ix := range s {
+		reqs = append(reqs, s[ix].String())
 	}
 	return strings.Join(reqs, ",")
 }
 
 // RequiresExactMatch introspect whether a given selector requires a single specific field
 // to be set, and if so returns the value it requires.
-func (lsel internalSelector) RequiresExactMatch(label string) (value string, found bool) {
-	for ix := range lsel {
-		if lsel[ix].key == label {
-			switch lsel[ix].operator {
+func (s internalSelector) RequiresExactMatch(label string) (value string, found bool) {
+	for ix := range s {
+		if s[ix].key == label {
+			switch s[ix].operator {
 			case selection.Equals, selection.DoubleEquals, selection.In:
-				if len(lsel[ix].strValues) == 1 {
-					return lsel[ix].strValues[0], true
+				if len(s[ix].strValues) == 1 {
+					return s[ix].strValues[0], true
 				}
 			}
 			return "", false
@@ -787,12 +789,12 @@ func (p *Parser) parseIdentifiersList() (sets.String, error) {
 // parseExactValue parses the only value for exact match style
 func (p *Parser) parseExactValue() (sets.String, error) {
 	s := sets.NewString()
-	tok, lit := p.lookahead(Values)
+	tok, _ := p.lookahead(Values)
 	if tok == EndOfStringToken || tok == CommaToken {
 		s.Insert("")
 		return s, nil
 	}
-	tok, lit = p.consume(Values)
+	tok, lit := p.consume(Values)
 	if tok == IdentifierToken {
 		s.Insert(lit)
 		return s, nil
@@ -869,23 +871,30 @@ func validateLabelValue(k, v string) error {
 
 // SelectorFromSet returns a Selector which will match exactly the given Set. A
 // nil and empty Sets are considered equivalent to Everything().
+// It does not perform any validation, which means the server will reject
+// the request if the Set contains invalid values.
 func SelectorFromSet(ls Set) Selector {
+	return SelectorFromValidatedSet(ls)
+}
+
+// ValidatedSelectorFromSet returns a Selector which will match exactly the given Set. A
+// nil and empty Sets are considered equivalent to Everything().
+// The Set is validated client-side, which allows to catch errors early.
+func ValidatedSelectorFromSet(ls Set) (Selector, error) {
 	if ls == nil || len(ls) == 0 {
-		return internalSelector{}
+		return internalSelector{}, nil
 	}
 	requirements := make([]Requirement, 0, len(ls))
 	for label, value := range ls {
 		r, err := NewRequirement(label, selection.Equals, []string{value})
-		if err == nil {
-			requirements = append(requirements, *r)
-		} else {
-			//TODO: double check errors when input comes from serialization?
-			return internalSelector{}
+		if err != nil {
+			return nil, err
 		}
+		requirements = append(requirements, *r)
 	}
 	// sort to have deterministic string representation
 	sort.Sort(ByKey(requirements))
-	return internalSelector(requirements)
+	return internalSelector(requirements), nil
 }
 
 // SelectorFromValidatedSet returns a Selector which will match exactly the given Set.