Upgrade k8s package verison (#5358)

* upgrade k8s package version

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

* Script upgrade and code formatting.

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/envconfig.go

@@ -0,0 +1,196 @@
+// Copyright The OpenTelemetry 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 otlpconfig
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.opentelemetry.io/otel/exporters/otlp"
+
+	"go.opentelemetry.io/otel"
+)
+
+func ApplyGRPCEnvConfigs(cfg *Config) {
+	e := EnvOptionsReader{
+		GetEnv:   os.Getenv,
+		ReadFile: ioutil.ReadFile,
+	}
+
+	e.ApplyGRPCEnvConfigs(cfg)
+}
+
+func ApplyHTTPEnvConfigs(cfg *Config) {
+	e := EnvOptionsReader{
+		GetEnv:   os.Getenv,
+		ReadFile: ioutil.ReadFile,
+	}
+
+	e.ApplyHTTPEnvConfigs(cfg)
+}
+
+type EnvOptionsReader struct {
+	GetEnv   func(string) string
+	ReadFile func(filename string) ([]byte, error)
+}
+
+func (e *EnvOptionsReader) ApplyHTTPEnvConfigs(cfg *Config) {
+	opts := e.GetOptionsFromEnv()
+	for _, opt := range opts {
+		opt.ApplyHTTPOption(cfg)
+	}
+}
+
+func (e *EnvOptionsReader) ApplyGRPCEnvConfigs(cfg *Config) {
+	opts := e.GetOptionsFromEnv()
+	for _, opt := range opts {
+		opt.ApplyGRPCOption(cfg)
+	}
+}
+
+func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
+	var opts []GenericOption
+
+	// Endpoint
+	if v, ok := e.getEnvValue("ENDPOINT"); ok {
+		opts = append(opts, WithEndpoint(v))
+	}
+	if v, ok := e.getEnvValue("TRACES_ENDPOINT"); ok {
+		opts = append(opts, WithTracesEndpoint(v))
+	}
+	if v, ok := e.getEnvValue("METRICS_ENDPOINT"); ok {
+		opts = append(opts, WithMetricsEndpoint(v))
+	}
+
+	// Certificate File
+	if path, ok := e.getEnvValue("CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp exporter certificate '%s': %w", path, err))
+		}
+	}
+	if path, ok := e.getEnvValue("TRACES_CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithTracesTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp traces exporter certificate '%s': %w", path, err))
+		}
+	}
+	if path, ok := e.getEnvValue("METRICS_CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithMetricsTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp metrics exporter certificate '%s': %w", path, err))
+		}
+	}
+
+	// Headers
+	if h, ok := e.getEnvValue("HEADERS"); ok {
+		opts = append(opts, WithHeaders(stringToHeader(h)))
+	}
+	if h, ok := e.getEnvValue("TRACES_HEADERS"); ok {
+		opts = append(opts, WithTracesHeaders(stringToHeader(h)))
+	}
+	if h, ok := e.getEnvValue("METRICS_HEADERS"); ok {
+		opts = append(opts, WithMetricsHeaders(stringToHeader(h)))
+	}
+
+	// Compression
+	if c, ok := e.getEnvValue("COMPRESSION"); ok {
+		opts = append(opts, WithCompression(stringToCompression(c)))
+	}
+	if c, ok := e.getEnvValue("TRACES_COMPRESSION"); ok {
+		opts = append(opts, WithTracesCompression(stringToCompression(c)))
+	}
+	if c, ok := e.getEnvValue("METRICS_COMPRESSION"); ok {
+		opts = append(opts, WithMetricsCompression(stringToCompression(c)))
+	}
+
+	// Timeout
+	if t, ok := e.getEnvValue("TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+	if t, ok := e.getEnvValue("TRACES_TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithTracesTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+	if t, ok := e.getEnvValue("METRICS_TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithMetricsTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+
+	return opts
+}
+
+// getEnvValue gets an OTLP environment variable value of the specified key using the GetEnv function.
+// This function already prepends the OTLP prefix to all key lookup.
+func (e *EnvOptionsReader) getEnvValue(key string) (string, bool) {
+	v := strings.TrimSpace(e.GetEnv(fmt.Sprintf("OTEL_EXPORTER_OTLP_%s", key)))
+	return v, v != ""
+}
+
+func (e *EnvOptionsReader) readTLSConfig(path string) (*tls.Config, error) {
+	b, err := e.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	return CreateTLSConfig(b)
+}
+
+func stringToCompression(value string) otlp.Compression {
+	switch value {
+	case "gzip":
+		return otlp.GzipCompression
+	}
+
+	return otlp.NoCompression
+}
+
+func stringToHeader(value string) map[string]string {
+	headersPairs := strings.Split(value, ",")
+	headers := make(map[string]string)
+
+	for _, header := range headersPairs {
+		nameValue := strings.SplitN(header, "=", 2)
+		if len(nameValue) < 2 {
+			continue
+		}
+		name, err := url.QueryUnescape(nameValue[0])
+		if err != nil {
+			continue
+		}
+		trimmedName := strings.TrimSpace(name)
+		value, err := url.QueryUnescape(nameValue[1])
+		if err != nil {
+			continue
+		}
+		trimmedValue := strings.TrimSpace(value)
+
+		headers[trimmedName] = trimmedValue
+	}
+
+	return headers
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/options.go

@@ -0,0 +1,376 @@
+// Copyright The OpenTelemetry 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 otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig"
+
+import (
+	"crypto/tls"
+	"fmt"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
+	"go.opentelemetry.io/otel/exporters/otlp"
+)
+
+const (
+	// DefaultMaxAttempts describes how many times the driver
+	// should retry the sending of the payload in case of a
+	// retryable error.
+	DefaultMaxAttempts int = 5
+	// DefaultTracesPath is a default URL path for endpoint that
+	// receives spans.
+	DefaultTracesPath string = "/v1/traces"
+	// DefaultMetricsPath is a default URL path for endpoint that
+	// receives metrics.
+	DefaultMetricsPath string = "/v1/metrics"
+	// DefaultBackoff is a default base backoff time used in the
+	// exponential backoff strategy.
+	DefaultBackoff time.Duration = 300 * time.Millisecond
+	// DefaultTimeout is a default max waiting time for the backend to process
+	// each span or metrics batch.
+	DefaultTimeout time.Duration = 10 * time.Second
+	// DefaultServiceConfig is the gRPC service config used if none is
+	// provided by the user.
+	DefaultServiceConfig = `{
+	"methodConfig":[{
+		"name":[
+			{ "service":"opentelemetry.proto.collector.metrics.v1.MetricsService" },
+			{ "service":"opentelemetry.proto.collector.trace.v1.TraceService" }
+		],
+		"retryPolicy":{
+			"MaxAttempts":5,
+			"InitialBackoff":"0.3s",
+			"MaxBackoff":"5s",
+			"BackoffMultiplier":2,
+			"RetryableStatusCodes":[
+				"CANCELLED",
+				"DEADLINE_EXCEEDED",
+				"RESOURCE_EXHAUSTED",
+				"ABORTED",
+				"OUT_OF_RANGE",
+				"UNAVAILABLE",
+				"DATA_LOSS"
+			]
+		}
+	}]
+}`
+)
+
+type (
+	SignalConfig struct {
+		Endpoint    string
+		Insecure    bool
+		TLSCfg      *tls.Config
+		Headers     map[string]string
+		Compression otlp.Compression
+		Timeout     time.Duration
+		URLPath     string
+
+		// gRPC configurations
+		GRPCCredentials credentials.TransportCredentials
+	}
+
+	Config struct {
+		// Signal specific configurations
+		Metrics SignalConfig
+		Traces  SignalConfig
+
+		// General configurations
+		MaxAttempts int
+		Backoff     time.Duration
+
+		// HTTP configuration
+		Marshaler otlp.Marshaler
+
+		// gRPC configurations
+		ReconnectionPeriod time.Duration
+		ServiceConfig      string
+		DialOptions        []grpc.DialOption
+	}
+)
+
+func NewDefaultConfig() Config {
+	c := Config{
+		Traces: SignalConfig{
+			Endpoint:    fmt.Sprintf("%s:%d", otlp.DefaultCollectorHost, otlp.DefaultCollectorPort),
+			URLPath:     DefaultTracesPath,
+			Compression: otlp.NoCompression,
+			Timeout:     DefaultTimeout,
+		},
+		Metrics: SignalConfig{
+			Endpoint:    fmt.Sprintf("%s:%d", otlp.DefaultCollectorHost, otlp.DefaultCollectorPort),
+			URLPath:     DefaultMetricsPath,
+			Compression: otlp.NoCompression,
+			Timeout:     DefaultTimeout,
+		},
+		MaxAttempts:   DefaultMaxAttempts,
+		Backoff:       DefaultBackoff,
+		ServiceConfig: DefaultServiceConfig,
+	}
+
+	return c
+}
+
+type (
+	// GenericOption applies an option to the HTTP or gRPC driver.
+	GenericOption interface {
+		ApplyHTTPOption(*Config)
+		ApplyGRPCOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+
+	// HTTPOption applies an option to the HTTP driver.
+	HTTPOption interface {
+		ApplyHTTPOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+
+	// GRPCOption applies an option to the gRPC driver.
+	GRPCOption interface {
+		ApplyGRPCOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+)
+
+// genericOption is an option that applies the same logic
+// for both gRPC and HTTP.
+type genericOption struct {
+	fn func(*Config)
+}
+
+func (g *genericOption) ApplyGRPCOption(cfg *Config) {
+	g.fn(cfg)
+}
+
+func (g *genericOption) ApplyHTTPOption(cfg *Config) {
+	g.fn(cfg)
+}
+
+func (genericOption) private() {}
+
+func newGenericOption(fn func(cfg *Config)) GenericOption {
+	return &genericOption{fn: fn}
+}
+
+// splitOption is an option that applies different logics
+// for gRPC and HTTP.
+type splitOption struct {
+	httpFn func(*Config)
+	grpcFn func(*Config)
+}
+
+func (g *splitOption) ApplyGRPCOption(cfg *Config) {
+	g.grpcFn(cfg)
+}
+
+func (g *splitOption) ApplyHTTPOption(cfg *Config) {
+	g.httpFn(cfg)
+}
+
+func (splitOption) private() {}
+
+func newSplitOption(httpFn func(cfg *Config), grpcFn func(cfg *Config)) GenericOption {
+	return &splitOption{httpFn: httpFn, grpcFn: grpcFn}
+}
+
+// httpOption is an option that is only applied to the HTTP driver.
+type httpOption struct {
+	fn func(*Config)
+}
+
+func (h *httpOption) ApplyHTTPOption(cfg *Config) {
+	h.fn(cfg)
+}
+
+func (httpOption) private() {}
+
+func NewHTTPOption(fn func(cfg *Config)) HTTPOption {
+	return &httpOption{fn: fn}
+}
+
+// grpcOption is an option that is only applied to the gRPC driver.
+type grpcOption struct {
+	fn func(*Config)
+}
+
+func (h *grpcOption) ApplyGRPCOption(cfg *Config) {
+	h.fn(cfg)
+}
+
+func (grpcOption) private() {}
+
+func NewGRPCOption(fn func(cfg *Config)) GRPCOption {
+	return &grpcOption{fn: fn}
+}
+
+// Generic Options
+
+func WithEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Endpoint = endpoint
+		cfg.Metrics.Endpoint = endpoint
+	})
+}
+
+func WithTracesEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Endpoint = endpoint
+	})
+}
+
+func WithMetricsEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Endpoint = endpoint
+	})
+}
+
+func WithCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Compression = compression
+		cfg.Metrics.Compression = compression
+	})
+}
+
+func WithTracesCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Compression = compression
+	})
+}
+
+func WithMetricsCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Compression = compression
+	})
+}
+
+func WithTracesURLPath(urlPath string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.URLPath = urlPath
+	})
+}
+
+func WithMetricsURLPath(urlPath string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.URLPath = urlPath
+	})
+}
+
+func WithMaxAttempts(maxAttempts int) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.MaxAttempts = maxAttempts
+	})
+}
+
+func WithBackoff(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Backoff = duration
+	})
+}
+
+func WithTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Traces.TLSCfg = tlsCfg.Clone()
+		cfg.Metrics.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Traces.GRPCCredentials = credentials.NewTLS(tlsCfg)
+		cfg.Metrics.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithTracesTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Traces.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Traces.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithMetricsTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Metrics.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Metrics.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithInsecure() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Insecure = true
+		cfg.Metrics.Insecure = true
+	})
+}
+
+func WithInsecureTraces() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Insecure = true
+	})
+}
+
+func WithInsecureMetrics() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Insecure = true
+	})
+}
+
+func WithHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Headers = headers
+		cfg.Metrics.Headers = headers
+	})
+}
+
+func WithTracesHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Headers = headers
+	})
+}
+
+func WithMetricsHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Headers = headers
+	})
+}
+
+func WithTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Timeout = duration
+		cfg.Metrics.Timeout = duration
+	})
+}
+
+func WithTracesTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Timeout = duration
+	})
+}
+
+func WithMetricsTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Timeout = duration
+	})
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/tls.go

@@ -0,0 +1,69 @@
+// Copyright The OpenTelemetry 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 otlpconfig
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"io/ioutil"
+)
+
+const (
+	WeakCertificate = `
+-----BEGIN CERTIFICATE-----
+MIIBhzCCASygAwIBAgIRANHpHgAWeTnLZpTSxCKs0ggwCgYIKoZIzj0EAwIwEjEQ
+MA4GA1UEChMHb3RlbC1nbzAeFw0yMTA0MDExMzU5MDNaFw0yMTA0MDExNDU5MDNa
+MBIxEDAOBgNVBAoTB290ZWwtZ28wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS9
+nWSkmPCxShxnp43F+PrOtbGV7sNfkbQ/kxzi9Ego0ZJdiXxkmv/C05QFddCW7Y0Z
+sJCLHGogQsYnWJBXUZOVo2MwYTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYI
+KwYBBQUHAwEwDAYDVR0TAQH/BAIwADAsBgNVHREEJTAjgglsb2NhbGhvc3SHEAAA
+AAAAAAAAAAAAAAAAAAGHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANwZVVKvfvQ/
+1HXsTvgH+xTQswOwSSKYJ1cVHQhqK7ZbAiEAus8NxpTRnp5DiTMuyVmhVNPB+bVH
+Lhnm4N/QDk5rek0=
+-----END CERTIFICATE-----
+`
+	WeakPrivateKey = `
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgN8HEXiXhvByrJ1zK
+SFT6Y2l2KqDWwWzKf+t4CyWrNKehRANCAAS9nWSkmPCxShxnp43F+PrOtbGV7sNf
+kbQ/kxzi9Ego0ZJdiXxkmv/C05QFddCW7Y0ZsJCLHGogQsYnWJBXUZOV
+-----END PRIVATE KEY-----
+`
+)
+
+// ReadTLSConfigFromFile reads a PEM certificate file and creates
+// a tls.Config that will use this certifate to verify a server certificate.
+func ReadTLSConfigFromFile(path string) (*tls.Config, error) {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return CreateTLSConfig(b)
+}
+
+// CreateTLSConfig creates a tls.Config from a raw certificate bytes
+// to verify a server certificate.
+func CreateTLSConfig(certBytes []byte) (*tls.Config, error) {
+	cp := x509.NewCertPool()
+	if ok := cp.AppendCertsFromPEM(certBytes); !ok {
+		return nil, errors.New("failed to append certificate to the cert pool")
+	}
+
+	return &tls.Config{
+		RootCAs: cp,
+	}, nil
+}