rebase: update kubernetes to v1.20.0

updated kubernetes packages to latest
release.

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

vendor/k8s.io/component-base/metrics/testutil/metrics.go

@@ -43,8 +43,8 @@ type Metrics map[string]model.Samples
 
 // Equal returns true if all metrics are the same as the arguments.
 func (m *Metrics) Equal(o Metrics) bool {
-	leftKeySet := []string{}
-	rightKeySet := []string{}
+	var leftKeySet []string
+	var rightKeySet []string
 	for k := range *m {
 		leftKeySet = append(leftKeySet, k)
 	}
@@ -86,35 +86,22 @@ func ParseMetrics(data string, output *Metrics) error {
 			continue
 		}
 		for _, metric := range v {
-			name := string(metric.Metric[model.MetricNameLabel])
+			name := string(metric.Metric[MetricNameLabel])
 			(*output)[name] = append((*output)[name], metric)
 		}
 	}
 }
 
-// ExtractMetricSamples parses the prometheus metric samples from the input string.
-func ExtractMetricSamples(metricsBlob string) ([]*model.Sample, error) {
-	dec := expfmt.NewDecoder(strings.NewReader(metricsBlob), expfmt.FmtText)
-	decoder := expfmt.SampleDecoder{
-		Dec:  dec,
-		Opts: &expfmt.DecodeOptions{},
-	}
-
-	var samples []*model.Sample
-	for {
-		var v model.Vector
-		if err := decoder.Decode(&v); err != nil {
-			if err == io.EOF {
-				// Expected loop termination condition.
-				return samples, nil
-			}
-			return nil, err
-		}
-		samples = append(samples, v...)
-	}
+// TextToMetricFamilies reads 'in' as the simple and flat text-based exchange
+// format and creates MetricFamily proto messages. It returns the MetricFamily
+// proto messages in a map where the metric names are the keys, along with any
+// error encountered.
+func TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricFamily, error) {
+	var textParser expfmt.TextParser
+	return textParser.TextToMetricFamilies(in)
 }
 
-// PrintSample returns formated representation of metric Sample
+// PrintSample returns formatted representation of metric Sample
 func PrintSample(sample *model.Sample) string {
 	buf := make([]string, 0)
 	// Id is a VERY special label. For 'normal' container it's useless, but it's necessary
@@ -198,22 +185,22 @@ func GetHistogramFromGatherer(gatherer metrics.Gatherer, metricName string) (His
 		return Histogram{}, err
 	}
 	for _, mFamily := range m {
-		if mFamily.Name != nil && *mFamily.Name == metricName {
+		if mFamily.GetName() == metricName {
 			metricFamily = mFamily
 			break
 		}
 	}
 
 	if metricFamily == nil {
-		return Histogram{}, fmt.Errorf("Metric %q not found", metricName)
+		return Histogram{}, fmt.Errorf("metric %q not found", metricName)
 	}
 
 	if metricFamily.GetMetric() == nil {
-		return Histogram{}, fmt.Errorf("Metric %q is empty", metricName)
+		return Histogram{}, fmt.Errorf("metric %q is empty", metricName)
 	}
 
 	if len(metricFamily.GetMetric()) == 0 {
-		return Histogram{}, fmt.Errorf("Metric %q is empty", metricName)
+		return Histogram{}, fmt.Errorf("metric %q is empty", metricName)
 	}
 
 	return Histogram{
@@ -253,6 +240,10 @@ func bucketQuantile(q float64, buckets []bucket) float64 {
 		return buckets[0].upperBound * (rank / buckets[0].count)
 	}
 
+	if b == len(buckets)-1 && math.IsInf(buckets[b].upperBound, 1) {
+		return buckets[len(buckets)-2].upperBound
+	}
+
 	// linear approximation of b-th bucket
 	brank := rank - buckets[b-1].count
 	bSize := buckets[b].upperBound - buckets[b-1].upperBound
@@ -264,24 +255,30 @@ func bucketQuantile(q float64, buckets []bucket) float64 {
 // Quantile computes q-th quantile of a cumulative histogram.
 // It's expected the histogram is valid (by calling Validate)
 func (hist *Histogram) Quantile(q float64) float64 {
-	buckets := []bucket{}
+	var buckets []bucket
 
 	for _, bckt := range hist.Bucket {
 		buckets = append(buckets, bucket{
-			count:      float64(*bckt.CumulativeCount),
-			upperBound: *bckt.UpperBound,
+			count:      float64(bckt.GetCumulativeCount()),
+			upperBound: bckt.GetUpperBound(),
 		})
 	}
 
-	// bucketQuantile expects the upper bound of the last bucket to be +inf
-	// buckets[len(buckets)-1].upperBound = math.Inf(+1)
+	if len(buckets) == 0 || buckets[len(buckets)-1].upperBound != math.Inf(+1) {
+		// The list of buckets in dto.Histogram doesn't include the final +Inf bucket, so we
+		// add it here for the reset of the samples.
+		buckets = append(buckets, bucket{
+			count:      float64(hist.GetSampleCount()),
+			upperBound: math.Inf(+1),
+		})
+	}
 
 	return bucketQuantile(q, buckets)
 }
 
 // Average computes histogram's average value
 func (hist *Histogram) Average() float64 {
-	return *hist.SampleSum / float64(*hist.SampleCount)
+	return hist.GetSampleSum() / float64(hist.GetSampleCount())
 }
 
 // Clear clears all fields of the wrapped histogram
@@ -301,11 +298,11 @@ func (hist *Histogram) Clear() {
 
 // Validate makes sure the wrapped histogram has all necessary fields set and with valid values.
 func (hist *Histogram) Validate() error {
-	if hist.SampleCount == nil || *hist.SampleCount == 0 {
+	if hist.SampleCount == nil || hist.GetSampleCount() == 0 {
 		return fmt.Errorf("nil or empty histogram SampleCount")
 	}
 
-	if hist.SampleSum == nil || *hist.SampleSum == 0 {
+	if hist.SampleSum == nil || hist.GetSampleSum() == 0 {
 		return fmt.Errorf("nil or empty histogram SampleSum")
 	}
 
@@ -313,7 +310,7 @@ func (hist *Histogram) Validate() error {
 		if bckt == nil {
 			return fmt.Errorf("empty histogram bucket")
 		}
-		if bckt.UpperBound == nil || *bckt.UpperBound < 0 {
+		if bckt.UpperBound == nil || bckt.GetUpperBound() < 0 {
 			return fmt.Errorf("nil or negative histogram bucket UpperBound")
 		}
 	}
@@ -325,7 +322,7 @@ func (hist *Histogram) Validate() error {
 func GetGaugeMetricValue(m metrics.GaugeMetric) (float64, error) {
 	metricProto := &dto.Metric{}
 	if err := m.Write(metricProto); err != nil {
-		return 0, fmt.Errorf("Error writing m: %v", err)
+		return 0, fmt.Errorf("error writing m: %v", err)
 	}
 	return metricProto.Gauge.GetValue(), nil
 }
@@ -334,7 +331,7 @@ func GetGaugeMetricValue(m metrics.GaugeMetric) (float64, error) {
 func GetCounterMetricValue(m metrics.CounterMetric) (float64, error) {
 	metricProto := &dto.Metric{}
 	if err := m.(metrics.Metric).Write(metricProto); err != nil {
-		return 0, fmt.Errorf("Error writing m: %v", err)
+		return 0, fmt.Errorf("error writing m: %v", err)
 	}
 	return metricProto.Counter.GetValue(), nil
 }
@@ -343,7 +340,29 @@ func GetCounterMetricValue(m metrics.CounterMetric) (float64, error) {
 func GetHistogramMetricValue(m metrics.ObserverMetric) (float64, error) {
 	metricProto := &dto.Metric{}
 	if err := m.(metrics.Metric).Write(metricProto); err != nil {
-		return 0, fmt.Errorf("Error writing m: %v", err)
+		return 0, fmt.Errorf("error writing m: %v", err)
 	}
 	return metricProto.Histogram.GetSampleSum(), nil
 }
+
+// LabelsMatch returns true if metric has all expected labels otherwise false
+func LabelsMatch(metric *dto.Metric, labelFilter map[string]string) bool {
+	metricLabels := map[string]string{}
+
+	for _, labelPair := range metric.Label {
+		metricLabels[labelPair.GetName()] = labelPair.GetValue()
+	}
+
+	// length comparison then match key to values in the maps
+	if len(labelFilter) > len(metricLabels) {
+		return false
+	}
+
+	for labelName, labelValue := range labelFilter {
+		if value, ok := metricLabels[labelName]; !ok || value != labelValue {
+			return false
+		}
+	}
+
+	return true
+}

vendor/k8s.io/component-base/metrics/testutil/promlint.go

@@ -0,0 +1,156 @@
+/*
+Copyright 2020 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 testutil
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus/testutil/promlint"
+)
+
+// exceptionMetrics is an exception list of metrics which violates promlint rules.
+//
+// The original entries come from the existing metrics when we introduce promlint.
+// We setup this list for allow and not fail on the current violations.
+// Generally speaking, you need to fix the problem for a new metric rather than add it into the list.
+var exceptionMetrics = []string{
+	// k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/server/egressselector
+	"apiserver_egress_dialer_dial_failure_count", // counter metrics should have "_total" suffix
+
+	// k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/server/healthz
+	"apiserver_request_total", // label names should be written in 'snake_case' not 'camelCase'
+
+	// k8s.io/kubernetes/vendor/k8s.io/apiserver/pkg/endpoints/filters
+	"authenticated_user_requests", // counter metrics should have "_total" suffix
+	"authentication_attempts",     // counter metrics should have "_total" suffix
+
+	// kube-apiserver
+	"aggregator_openapi_v2_regeneration_count",
+	"apiserver_admission_step_admission_duration_seconds_summary",
+	"apiserver_current_inflight_requests",
+	"apiserver_longrunning_gauge",
+	"get_token_count",
+	"get_token_fail_count",
+	"ssh_tunnel_open_count",
+	"ssh_tunnel_open_fail_count",
+
+	// kube-controller-manager
+	"attachdetach_controller_forced_detaches",
+	"authenticated_user_requests",
+	"authentication_attempts",
+	"get_token_count",
+	"get_token_fail_count",
+	"node_collector_evictions_number",
+
+	// k8s.io/kubernetes/pkg/kubelet/server/stats
+	// The two metrics have been deprecated and will be removed in release v1.20+.
+	"container_cpu_usage_seconds_total", // non-counter metrics should not have "_total" suffix
+	"node_cpu_usage_seconds_total",      // non-counter metrics should not have "_total" suffix
+}
+
+// A Problem is an issue detected by a Linter.
+type Problem promlint.Problem
+
+func (p *Problem) String() string {
+	return fmt.Sprintf("%s:%s", p.Metric, p.Text)
+}
+
+// A Linter is a Prometheus metrics linter.  It identifies issues with metric
+// names, types, and metadata, and reports them to the caller.
+type Linter struct {
+	promLinter *promlint.Linter
+}
+
+// Lint performs a linting pass, returning a slice of Problems indicating any
+// issues found in the metrics stream.  The slice is sorted by metric name
+// and issue description.
+func (l *Linter) Lint() ([]Problem, error) {
+	promProblems, err := l.promLinter.Lint()
+	if err != nil {
+		return nil, err
+	}
+
+	// Ignore problems those in exception list
+	problems := make([]Problem, 0, len(promProblems))
+	for i := range promProblems {
+		if !l.shouldIgnore(promProblems[i].Metric) {
+			problems = append(problems, Problem(promProblems[i]))
+		}
+	}
+
+	return problems, nil
+}
+
+// shouldIgnore returns true if metric in the exception list, otherwise returns false.
+func (l *Linter) shouldIgnore(metricName string) bool {
+	for i := range exceptionMetrics {
+		if metricName == exceptionMetrics[i] {
+			return true
+		}
+	}
+
+	return false
+}
+
+// NewPromLinter creates a new Linter that reads an input stream of Prometheus metrics.
+// Only the text exposition format is supported.
+func NewPromLinter(r io.Reader) *Linter {
+	return &Linter{
+		promLinter: promlint.New(r),
+	}
+}
+
+func mergeProblems(problems []Problem) string {
+	var problemsMsg []string
+
+	for index := range problems {
+		problemsMsg = append(problemsMsg, problems[index].String())
+	}
+
+	return strings.Join(problemsMsg, ",")
+}
+
+// shouldIgnore returns true if metric in the exception list, otherwise returns false.
+func shouldIgnore(metricName string) bool {
+	for i := range exceptionMetrics {
+		if metricName == exceptionMetrics[i] {
+			return true
+		}
+	}
+
+	return false
+}
+
+// getLintError will ignore the metrics in exception list and converts lint problem to error.
+func getLintError(problems []promlint.Problem) error {
+	var filteredProblems []Problem
+	for _, problem := range problems {
+		if shouldIgnore(problem.Metric) {
+			continue
+		}
+
+		filteredProblems = append(filteredProblems, Problem(problem))
+	}
+
+	if len(filteredProblems) == 0 {
+		return nil
+	}
+
+	return fmt.Errorf("lint error: %s", mergeProblems(filteredProblems))
+}

vendor/k8s.io/component-base/metrics/testutil/testutil.go

@@ -30,6 +30,14 @@ import (
 // pedantic Registry. It then does the same as GatherAndCompare, gathering the
 // metrics from the pedantic Registry.
 func CollectAndCompare(c metrics.Collector, expected io.Reader, metricNames ...string) error {
+	lintProblems, err := testutil.CollectAndLint(c, metricNames...)
+	if err != nil {
+		return err
+	}
+	if err := getLintError(lintProblems); err != nil {
+		return err
+	}
+
 	return testutil.CollectAndCompare(c, expected, metricNames...)
 }
 
@@ -38,6 +46,14 @@ func CollectAndCompare(c metrics.Collector, expected io.Reader, metricNames ...s
 // exposition format. If any metricNames are provided, only metrics with those
 // names are compared.
 func GatherAndCompare(g metrics.Gatherer, expected io.Reader, metricNames ...string) error {
+	lintProblems, err := testutil.GatherAndLint(g, metricNames...)
+	if err != nil {
+		return err
+	}
+	if err := getLintError(lintProblems); err != nil {
+		return err
+	}
+
 	return testutil.GatherAndCompare(g, expected, metricNames...)
 }