From 5d1b08e4cd270d84152fdde0b13d643b1bca0576 Mon Sep 17 00:00:00 2001 From: Sam Fowler Date: Tue, 6 Oct 2020 11:10:38 +1000 Subject: [PATCH 001/301] Mask bearer token in logs when logLevel >= 9 --- staging/src/k8s.io/client-go/transport/round_trippers.go | 1 + 1 file changed, 1 insertion(+) diff --git a/staging/src/k8s.io/client-go/transport/round_trippers.go b/staging/src/k8s.io/client-go/transport/round_trippers.go index a05208d924d3b..f4cfadbd3da8e 100644 --- a/staging/src/k8s.io/client-go/transport/round_trippers.go +++ b/staging/src/k8s.io/client-go/transport/round_trippers.go @@ -340,6 +340,7 @@ func (r *requestInfo) toCurl() string { headers := "" for key, values := range r.RequestHeaders { for _, value := range values { + value = maskValue(key, value) headers += fmt.Sprintf(` -H %q`, fmt.Sprintf("%s: %s", key, value)) } } From dd61349e0ac92849d7e5aa0cc684f87217c43db9 Mon Sep 17 00:00:00 2001 From: Antoine Pelisse Date: Thu, 1 Oct 2020 10:53:16 -0700 Subject: [PATCH 002/301] Do not update managedFields timestamp when they don't change --- .../pkg/endpoints/handlers/fieldmanager/BUILD | 1 + .../fieldmanager/managedfieldsupdater.go | 6 +- .../fieldmanager/managedfieldsupdater_test.go | 66 +++++++++++++++++++ 3 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater_test.go diff --git a/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/BUILD b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/BUILD index 1a7b9961d4d65..4ebd85e7f4fb7 100644 --- a/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/BUILD +++ b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/BUILD @@ -56,6 +56,7 @@ go_test( "fieldmanager_test.go", "lastappliedmanager_test.go", "lastappliedupdater_test.go", + "managedfieldsupdater_test.go", "skipnonapplied_test.go", ], data = [ diff --git a/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go index b3ecd63933354..9bee82a854f1b 100644 --- a/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go +++ b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater.go @@ -44,6 +44,7 @@ func NewManagedFieldsUpdater(fieldManager Manager) Manager { // Update implements Manager. func (f *managedFieldsUpdater) Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error) { self := "current-operation" + formerSet := managed.Fields()[manager] object, managed, err := f.fieldManager.Update(liveObj, newObj, managed, self) if err != nil { return object, managed, err @@ -54,12 +55,15 @@ func (f *managedFieldsUpdater) Update(liveObj, newObj runtime.Object, managed Ma if vs, ok := managed.Fields()[self]; ok { delete(managed.Fields(), self) - managed.Times()[manager] = &metav1.Time{Time: time.Now().UTC()} if previous, ok := managed.Fields()[manager]; ok { managed.Fields()[manager] = fieldpath.NewVersionedSet(vs.Set().Union(previous.Set()), vs.APIVersion(), vs.Applied()) } else { managed.Fields()[manager] = vs } + // Update the time only if the manager's fieldSet has changed. + if formerSet == nil || !managed.Fields()[manager].Set().Equals(formerSet.Set()) { + managed.Times()[manager] = &metav1.Time{Time: time.Now().UTC()} + } } return object, managed, nil diff --git a/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater_test.go b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater_test.go new file mode 100644 index 0000000000000..9d8bfc4e0c904 --- /dev/null +++ b/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/managedfieldsupdater_test.go @@ -0,0 +1,66 @@ +/* +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 fieldmanager_test + +import ( + "reflect" + "testing" + "time" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/yaml" +) + +func TestNoManagedFieldsUpdateDoesntUpdateTime(t *testing.T) { + f := NewTestFieldManager(schema.FromAPIVersionAndKind("v1", "Pod"), nil) + + obj := &unstructured.Unstructured{Object: map[string]interface{}{}} + if err := yaml.Unmarshal([]byte(`{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": { + "name": "pod", + "labels": {"app": "nginx"} + }, + }`), &obj.Object); err != nil { + t.Fatalf("error decoding YAML: %v", err) + } + + if err := f.Update(obj, "fieldmanager_test"); err != nil { + t.Fatalf("failed to update object: %v", err) + } + managed := f.ManagedFields() + obj2 := &unstructured.Unstructured{Object: map[string]interface{}{}} + if err := yaml.Unmarshal([]byte(`{ + "apiVersion": "v1", + "kind": "Pod", + "metadata": { + "name": "pod", + "labels": {"app": "nginx2"} + }, + }`), &obj2.Object); err != nil { + t.Fatalf("error decoding YAML: %v", err) + } + time.Sleep(time.Second) + if err := f.Update(obj2, "fieldmanager_test"); err != nil { + t.Fatalf("failed to update object: %v", err) + } + if !reflect.DeepEqual(managed, f.ManagedFields()) { + t.Errorf("ManagedFields changed:\nBefore:\n%v\nAfter:\n%v", managed, f.ManagedFields()) + } +} From 28af363da852b4c6d25bea7dac4395bc3aa2da1a Mon Sep 17 00:00:00 2001 From: Lukasz Szaszkiewicz Date: Tue, 20 Oct 2020 14:39:45 +0200 Subject: [PATCH 003/301] DelegatingAuthorizationOptions: exposes and sets a default timeout for SubjectAccessReview client previously no timeout was set. Requests without explicit timeout might potentially hang forever and lead to starvation of the application. --- .../app/options/options_test.go | 2 ++ .../app/options/options_test.go | 1 + .../apiserver/pkg/server/options/authorization.go | 11 +++++++++++ 3 files changed, 14 insertions(+) diff --git a/cmd/cloud-controller-manager/app/options/options_test.go b/cmd/cloud-controller-manager/app/options/options_test.go index 272cfca5d0106..00815103f21f5 100644 --- a/cmd/cloud-controller-manager/app/options/options_test.go +++ b/cmd/cloud-controller-manager/app/options/options_test.go @@ -115,6 +115,7 @@ func TestDefaultFlags(t *testing.T) { Authorization: &apiserveroptions.DelegatingAuthorizationOptions{ AllowCacheTTL: 10 * time.Second, DenyCacheTTL: 10 * time.Second, + ClientTimeout: 10 * time.Second, RemoteKubeConfigFileOptional: true, AlwaysAllowPaths: []string{"/healthz"}, // note: this does not match /healthz/ or }, @@ -247,6 +248,7 @@ func TestAddFlags(t *testing.T) { Authorization: &apiserveroptions.DelegatingAuthorizationOptions{ AllowCacheTTL: 10 * time.Second, DenyCacheTTL: 10 * time.Second, + ClientTimeout: 10 * time.Second, RemoteKubeConfigFileOptional: true, AlwaysAllowPaths: []string{"/healthz"}, // note: this does not match /healthz/ or }, diff --git a/cmd/kube-controller-manager/app/options/options_test.go b/cmd/kube-controller-manager/app/options/options_test.go index 59e0d2522909d..24373dc3e5fd0 100644 --- a/cmd/kube-controller-manager/app/options/options_test.go +++ b/cmd/kube-controller-manager/app/options/options_test.go @@ -411,6 +411,7 @@ func TestAddFlags(t *testing.T) { Authorization: &apiserveroptions.DelegatingAuthorizationOptions{ AllowCacheTTL: 10 * time.Second, DenyCacheTTL: 10 * time.Second, + ClientTimeout: 10 * time.Second, RemoteKubeConfigFileOptional: true, AlwaysAllowPaths: []string{"/healthz"}, // note: this does not match /healthz/ or /healthz/* }, diff --git a/staging/src/k8s.io/apiserver/pkg/server/options/authorization.go b/staging/src/k8s.io/apiserver/pkg/server/options/authorization.go index 8b1718b4012c5..818228954e663 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/options/authorization.go +++ b/staging/src/k8s.io/apiserver/pkg/server/options/authorization.go @@ -59,6 +59,10 @@ type DelegatingAuthorizationOptions struct { // AlwaysAllowGroups are groups which are allowed to take any actions. In kube, this is system:masters. AlwaysAllowGroups []string + + // ClientTimeout specifies a time limit for requests made by SubjectAccessReviews client. + // The default value is set to 10 seconds. + ClientTimeout time.Duration } func NewDelegatingAuthorizationOptions() *DelegatingAuthorizationOptions { @@ -66,6 +70,7 @@ func NewDelegatingAuthorizationOptions() *DelegatingAuthorizationOptions { // very low for responsiveness, but high enough to handle storms AllowCacheTTL: 10 * time.Second, DenyCacheTTL: 10 * time.Second, + ClientTimeout: 10 * time.Second, } } @@ -81,6 +86,11 @@ func (s *DelegatingAuthorizationOptions) WithAlwaysAllowPaths(paths ...string) * return s } +// WithClientTimeout sets the given timeout for SAR client used by this authorizer +func (s *DelegatingAuthorizationOptions) WithClientTimeout(timeout time.Duration) { + s.ClientTimeout = timeout +} + func (s *DelegatingAuthorizationOptions) Validate() []error { allErrors := []error{} return allErrors @@ -186,6 +196,7 @@ func (s *DelegatingAuthorizationOptions) getClient() (kubernetes.Interface, erro // set high qps/burst limits since this will effectively limit API server responsiveness clientConfig.QPS = 200 clientConfig.Burst = 400 + clientConfig.Timeout = s.ClientTimeout return kubernetes.NewForConfig(clientConfig) } From 8af0b186993d12ae606d45514063e6947173c618 Mon Sep 17 00:00:00 2001 From: ravisantoshgudimetla Date: Fri, 30 Oct 2020 20:06:58 +0530 Subject: [PATCH 004/301] Allow priority to be set for kubelet process on Windows --- cmd/kubelet/app/init_others.go | 2 +- cmd/kubelet/app/init_windows.go | 32 +++++++++++++++- cmd/kubelet/app/init_windows_test.go | 44 ++++++++++++++++++++++ cmd/kubelet/app/options/options.go | 7 ++++ cmd/kubelet/app/options/osflags_windows.go | 6 +++ cmd/kubelet/app/server.go | 2 +- 6 files changed, 90 insertions(+), 3 deletions(-) create mode 100644 cmd/kubelet/app/init_windows_test.go diff --git a/cmd/kubelet/app/init_others.go b/cmd/kubelet/app/init_others.go index 4b19ac91b288d..1fe895f5d0ac4 100644 --- a/cmd/kubelet/app/init_others.go +++ b/cmd/kubelet/app/init_others.go @@ -18,6 +18,6 @@ limitations under the License. package app -func initForOS(service bool) error { +func initForOS(service bool, priorityClass string) error { return nil } diff --git a/cmd/kubelet/app/init_windows.go b/cmd/kubelet/app/init_windows.go index a2da4cf04985b..bed76806701f5 100644 --- a/cmd/kubelet/app/init_windows.go +++ b/cmd/kubelet/app/init_windows.go @@ -19,6 +19,10 @@ limitations under the License. package app import ( + "fmt" + + "golang.org/x/sys/windows" + "k8s.io/klog/v2" "k8s.io/kubernetes/pkg/windows/service" ) @@ -26,7 +30,33 @@ const ( serviceName = "kubelet" ) -func initForOS(windowsService bool) error { +// getPriorityValue returns the value associated with a Windows process priorityClass +// Ref: https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/setpriority-method-in-class-win32-process +func getPriorityValue(priorityClassName string) uint32 { + var priorityClassMap = map[string]uint32{ + "IDLE_PRIORITY_CLASS": uint32(64), + "BELOW_NORMAL_PRIORITY_CLASS": uint32(16384), + "NORMAL_PRIORITY_CLASS": uint32(32), + "ABOVE_NORMAL_PRIORITY_CLASS": uint32(32768), + "HIGH_PRIORITY_CLASS": uint32(128), + "REALTIME_PRIORITY_CLASS": uint32(256), + } + return priorityClassMap[priorityClassName] +} + +func initForOS(windowsService bool, windowsPriorityClass string) error { + priority := getPriorityValue(windowsPriorityClass) + if priority == 0 { + return fmt.Errorf("unknown priority class %s, valid ones are available at "+ + "https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities", windowsPriorityClass) + } + kubeletProcessHandle := windows.CurrentProcess() + // Set the priority of the kubelet process to given priority + klog.Infof("Setting the priority of kubelet process to %s", windowsPriorityClass) + if err := windows.SetPriorityClass(kubeletProcessHandle, priority); err != nil { + return err + } + if windowsService { return service.InitService(serviceName) } diff --git a/cmd/kubelet/app/init_windows_test.go b/cmd/kubelet/app/init_windows_test.go new file mode 100644 index 0000000000000..2920e8c69c814 --- /dev/null +++ b/cmd/kubelet/app/init_windows_test.go @@ -0,0 +1,44 @@ +/* +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 app + +import "testing" + +func TestIsValidPriorityClass(t *testing.T) { + testCases := []struct { + description string + priorityClassName string + expectedPriorityValue uint32 + }{ + { + description: "Invalid Priority Class", + priorityClassName: "myPriorityClass", + expectedPriorityValue: 0, + }, + { + description: "Valid Priority Class", + priorityClassName: "IDLE_PRIORITY_CLASS", + expectedPriorityValue: uint32(64), + }, + } + for _, test := range testCases { + actualPriorityValue := getPriorityValue(test.priorityClassName) + if test.expectedPriorityValue != actualPriorityValue { + t.Fatalf("unexpected error for %s", test.description) + } + } +} diff --git a/cmd/kubelet/app/options/options.go b/cmd/kubelet/app/options/options.go index 8306387ea8be9..7e4f8fd18a14b 100644 --- a/cmd/kubelet/app/options/options.go +++ b/cmd/kubelet/app/options/options.go @@ -111,6 +111,13 @@ type KubeletFlags struct { // Its corresponding flag only gets registered in Windows builds. WindowsService bool + // WindowsPriorityClass sets the priority class associated with the Kubelet process + // Its corresponding flag only gets registered in Windows builds + // The default priority class associated with any process in Windows is NORMAL_PRIORITY_CLASS. Keeping it as is + // to maintain backwards compatibility. + // Source: https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities + WindowsPriorityClass string + // remoteRuntimeEndpoint is the endpoint of remote runtime service RemoteRuntimeEndpoint string // remoteImageEndpoint is the endpoint of remote image service diff --git a/cmd/kubelet/app/options/osflags_windows.go b/cmd/kubelet/app/options/osflags_windows.go index 8923f5d6f1d36..95ee23483e65e 100644 --- a/cmd/kubelet/app/options/osflags_windows.go +++ b/cmd/kubelet/app/options/osflags_windows.go @@ -24,4 +24,10 @@ import ( func (f *KubeletFlags) addOSFlags(fs *pflag.FlagSet) { fs.BoolVar(&f.WindowsService, "windows-service", f.WindowsService, "Enable Windows Service Control Manager API integration") + // The default priority class associated with any process in Windows is NORMAL_PRIORITY_CLASS. Keeping it as is + // to maintain backwards compatibility. + // Source: https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities + fs.StringVar(&f.WindowsPriorityClass, "windows-priorityclass", "NORMAL_PRIORITY_CLASS", + "Set the PriorityClass associated with kubelet process, the default ones are available at "+ + "https://docs.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities") } diff --git a/cmd/kubelet/app/server.go b/cmd/kubelet/app/server.go index b1c4921fa3bb0..7baf008b5e71e 100644 --- a/cmd/kubelet/app/server.go +++ b/cmd/kubelet/app/server.go @@ -409,7 +409,7 @@ func Run(ctx context.Context, s *options.KubeletServer, kubeDeps *kubelet.Depend logOption.Apply() // To help debugging, immediately log version klog.Infof("Version: %+v", version.Get()) - if err := initForOS(s.KubeletFlags.WindowsService); err != nil { + if err := initForOS(s.KubeletFlags.WindowsService, s.KubeletFlags.WindowsPriorityClass); err != nil { return fmt.Errorf("failed OS init: %v", err) } if err := run(ctx, s, kubeDeps, featureGate); err != nil { From 68a70d3dfec0ff7e15cfd6eeea627159281e7d95 Mon Sep 17 00:00:00 2001 From: ravisantoshgudimetla Date: Fri, 30 Oct 2020 20:32:51 +0530 Subject: [PATCH 005/301] Build files --- cmd/kubelet/app/BUILD | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cmd/kubelet/app/BUILD b/cmd/kubelet/app/BUILD index 7a175668c2182..9ed7a31356a17 100644 --- a/cmd/kubelet/app/BUILD +++ b/cmd/kubelet/app/BUILD @@ -133,6 +133,7 @@ go_library( ], "@io_bazel_rules_go//go/platform:windows": [ "//pkg/windows/service:go_default_library", + "//vendor/golang.org/x/sys/windows:go_default_library", ], "//conditions:default": [], }), @@ -141,6 +142,7 @@ go_library( go_test( name = "go_default_test", srcs = [ + "init_windows_test.go", "server_bootstrap_test.go", "server_test.go", ], From d67a36d1daa42660f23253e1b77061454daa7689 Mon Sep 17 00:00:00 2001 From: brianpursley Date: Sun, 1 Nov 2020 10:41:19 -0500 Subject: [PATCH 006/301] Fix bug in JSON path parser where an error occurs when a range is empty --- .../k8s.io/client-go/util/jsonpath/jsonpath.go | 16 +++++++++++++--- .../client-go/util/jsonpath/jsonpath_test.go | 15 +++++++++++++++ 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/staging/src/k8s.io/client-go/util/jsonpath/jsonpath.go b/staging/src/k8s.io/client-go/util/jsonpath/jsonpath.go index 9740fe69d0253..49ecd1465ae9a 100644 --- a/staging/src/k8s.io/client-go/util/jsonpath/jsonpath.go +++ b/staging/src/k8s.io/client-go/util/jsonpath/jsonpath.go @@ -103,13 +103,23 @@ func (j *JSONPath) FindResults(data interface{}) ([][]reflect.Value, error) { if j.beginRange > 0 { j.beginRange-- j.inRange++ - for _, value := range results { + if len(results) > 0 { + for _, value := range results { + j.parser.Root.Nodes = nodes[i+1:] + nextResults, err := j.FindResults(value.Interface()) + if err != nil { + return nil, err + } + fullResult = append(fullResult, nextResults...) + } + } else { + // If the range has no results, we still need to process the nodes within the range + // so the position will advance to the end node j.parser.Root.Nodes = nodes[i+1:] - nextResults, err := j.FindResults(value.Interface()) + _, err := j.FindResults(nil) if err != nil { return nil, err } - fullResult = append(fullResult, nextResults...) } j.inRange-- diff --git a/staging/src/k8s.io/client-go/util/jsonpath/jsonpath_test.go b/staging/src/k8s.io/client-go/util/jsonpath/jsonpath_test.go index e15c4097d1c6f..34a0f9e7de8ae 100644 --- a/staging/src/k8s.io/client-go/util/jsonpath/jsonpath_test.go +++ b/staging/src/k8s.io/client-go/util/jsonpath/jsonpath_test.go @@ -393,6 +393,21 @@ func TestKubernetes(t *testing.T) { testJSONPathSortOutput(randomPrintOrderTests, t) } +func TestEmptyRange(t *testing.T) { + var input = []byte(`{"items":[]}`) + var emptyList interface{} + err := json.Unmarshal(input, &emptyList) + if err != nil { + t.Error(err) + } + + tests := []jsonpathTest{ + {"empty range", `{range .items[*]}{.metadata.name}{end}`, &emptyList, "", false}, + {"empty nested range", `{range .items[*]}{.metadata.name}{":"}{range @.spec.containers[*]}{.name}{","}{end}{"+"}{end}`, &emptyList, "", false}, + } + testJSONPath(tests, true, t) +} + func TestNestedRanges(t *testing.T) { var input = []byte(`{ "items": [ From 777e32abfe2c8b617b73c9ffb939723d3af236ad Mon Sep 17 00:00:00 2001 From: staebler Date: Mon, 5 Oct 2020 11:26:48 -0400 Subject: [PATCH 007/301] do not allow inflight watermark histograms to fall too far behind The MaxInFlight and PriorityAndFairness apiserver filters maintain watermarks with histogram metrics that are observed when requests are handled. When a request is received, the watermark observer needs to fill out observations for the entire time period since the last request was received. If it has been a long time since a request has been received, then it can take an inordinate amount of time to fill out the observations, to the extent that the request may time out. To combat this, these changes will have the filters fill out the observations on a 10-second interval, so that the observations never fall too far behind. This follows a similar approach taken in 9e89b92a92c02cdd2c70c0f52a30936e9c3309c7. https://github.com/kubernetes/kubernetes/issues/95300 The Priority-and-Fairness and Max-in-Flight filters start goroutines to handle some maintenance tasks on the watermarks for those filters. Once started, these goroutines run forever. Instead, the goroutines should have a lifetime tied to the lifetime of the apiserver. These changes move the functionality for starting the goroutines to a PostStartHook. The goroutines have been changed to accept a stop channel and only run until the stop channel is closed. --- .../src/k8s.io/apiserver/pkg/server/config.go | 25 ++++++++++ .../apiserver/pkg/server/config_test.go | 4 ++ .../pkg/server/filters/maxinflight.go | 47 ++++++++++++------- .../pkg/server/filters/maxinflight_test.go | 13 +++++ .../server/filters/priority-and-fairness.go | 11 +++-- 5 files changed, 80 insertions(+), 20 deletions(-) diff --git a/staging/src/k8s.io/apiserver/pkg/server/config.go b/staging/src/k8s.io/apiserver/pkg/server/config.go index 9699177ff2e8b..3a2eece954ce5 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/config.go +++ b/staging/src/k8s.io/apiserver/pkg/server/config.go @@ -638,6 +638,31 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G klog.V(3).Infof("Not requested to run hook %s", priorityAndFairnessConfigConsumerHookName) } + // Add PostStartHooks for maintaining the watermarks for the Priority-and-Fairness and the Max-in-Flight filters. + if c.FlowControl != nil { + const priorityAndFairnessFilterHookName = "priority-and-fairness-filter" + if !s.isPostStartHookRegistered(priorityAndFairnessFilterHookName) { + err := s.AddPostStartHook(priorityAndFairnessFilterHookName, func(context PostStartHookContext) error { + genericfilters.StartPriorityAndFairnessWatermarkMaintenance(context.StopCh) + return nil + }) + if err != nil { + return nil, err + } + } + } else { + const maxInFlightFilterHookName = "max-in-flight-filter" + if !s.isPostStartHookRegistered(maxInFlightFilterHookName) { + err := s.AddPostStartHook(maxInFlightFilterHookName, func(context PostStartHookContext) error { + genericfilters.StartMaxInFlightWatermarkMaintenance(context.StopCh) + return nil + }) + if err != nil { + return nil, err + } + } + } + for _, delegateCheck := range delegationTarget.HealthzChecks() { skip := false for _, existingCheck := range c.HealthzChecks { diff --git a/staging/src/k8s.io/apiserver/pkg/server/config_test.go b/staging/src/k8s.io/apiserver/pkg/server/config_test.go index fbd32097c8bd2..ae5e23c084a5b 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/config_test.go +++ b/staging/src/k8s.io/apiserver/pkg/server/config_test.go @@ -155,6 +155,7 @@ func TestNewWithDelegate(t *testing.T) { "/healthz/ping", "/healthz/poststarthook/delegate-post-start-hook", "/healthz/poststarthook/generic-apiserver-start-informers", + "/healthz/poststarthook/max-in-flight-filter", "/healthz/poststarthook/wrapping-post-start-hook", "/healthz/wrapping-health", "/livez", @@ -163,6 +164,7 @@ func TestNewWithDelegate(t *testing.T) { "/livez/ping", "/livez/poststarthook/delegate-post-start-hook", "/livez/poststarthook/generic-apiserver-start-informers", + "/livez/poststarthook/max-in-flight-filter", "/livez/poststarthook/wrapping-post-start-hook", "/metrics", "/readyz", @@ -172,6 +174,7 @@ func TestNewWithDelegate(t *testing.T) { "/readyz/ping", "/readyz/poststarthook/delegate-post-start-hook", "/readyz/poststarthook/generic-apiserver-start-informers", + "/readyz/poststarthook/max-in-flight-filter", "/readyz/poststarthook/wrapping-post-start-hook", "/readyz/shutdown", } @@ -181,6 +184,7 @@ func TestNewWithDelegate(t *testing.T) { [-]wrapping-health failed: reason withheld [-]delegate-health failed: reason withheld [+]poststarthook/generic-apiserver-start-informers ok +[+]poststarthook/max-in-flight-filter ok [+]poststarthook/delegate-post-start-hook ok [+]poststarthook/wrapping-post-start-hook ok healthz check failed diff --git a/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight.go b/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight.go index 946ab4e605de9..e873351c70bf7 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight.go +++ b/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight.go @@ -41,6 +41,10 @@ const ( // the metrics tracks maximal value over period making this // longer will increase the metric value. inflightUsageMetricUpdatePeriod = time.Second + + // How often to run maintenance on observations to ensure + // that they do not fall too far behind. + observationMaintenancePeriod = 10 * time.Second ) var nonMutatingRequestVerbs = sets.NewString("get", "list", "watch") @@ -88,23 +92,29 @@ var watermark = &requestWatermark{ mutatingObserver: fcmetrics.ReadWriteConcurrencyObserverPairGenerator.Generate(1, 1, []string{metrics.MutatingKind}).RequestsExecuting, } -func startRecordingUsage(watermark *requestWatermark) { - go func() { - wait.Forever(func() { - watermark.lock.Lock() - readOnlyWatermark := watermark.readOnlyWatermark - mutatingWatermark := watermark.mutatingWatermark - watermark.readOnlyWatermark = 0 - watermark.mutatingWatermark = 0 - watermark.lock.Unlock() - - metrics.UpdateInflightRequestMetrics(watermark.phase, readOnlyWatermark, mutatingWatermark) - }, inflightUsageMetricUpdatePeriod) - }() +// startWatermarkMaintenance starts the goroutines to observe and maintain the specified watermark. +func startWatermarkMaintenance(watermark *requestWatermark, stopCh <-chan struct{}) { + // Periodically update the inflight usage metric. + go wait.Until(func() { + watermark.lock.Lock() + readOnlyWatermark := watermark.readOnlyWatermark + mutatingWatermark := watermark.mutatingWatermark + watermark.readOnlyWatermark = 0 + watermark.mutatingWatermark = 0 + watermark.lock.Unlock() + + metrics.UpdateInflightRequestMetrics(watermark.phase, readOnlyWatermark, mutatingWatermark) + }, inflightUsageMetricUpdatePeriod, stopCh) + + // Periodically observe the watermarks. This is done to ensure that they do not fall too far behind. When they do + // fall too far behind, then there is a long delay in responding to the next request received while the observer + // catches back up. + go wait.Until(func() { + watermark.readOnlyObserver.Add(0) + watermark.mutatingObserver.Add(0) + }, observationMaintenancePeriod, stopCh) } -var startOnce sync.Once - // WithMaxInFlightLimit limits the number of in-flight requests to buffer size of the passed in channel. func WithMaxInFlightLimit( handler http.Handler, @@ -112,7 +122,6 @@ func WithMaxInFlightLimit( mutatingLimit int, longRunningRequestCheck apirequest.LongRunningRequestCheck, ) http.Handler { - startOnce.Do(func() { startRecordingUsage(watermark) }) if nonMutatingLimit == 0 && mutatingLimit == 0 { return handler } @@ -198,6 +207,12 @@ func WithMaxInFlightLimit( }) } +// StartMaxInFlightWatermarkMaintenance starts the goroutines to observe and maintain watermarks for max-in-flight +// requests. +func StartMaxInFlightWatermarkMaintenance(stopCh <-chan struct{}) { + startWatermarkMaintenance(watermark, stopCh) +} + func tooManyRequests(req *http.Request, w http.ResponseWriter) { // Return a 429 status indicating "Too Many Requests" w.Header().Set("Retry-After", retryAfter) diff --git a/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight_test.go b/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight_test.go index c3b4c53d35e71..3bbcace923043 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight_test.go +++ b/staging/src/k8s.io/apiserver/pkg/server/filters/maxinflight_test.go @@ -17,6 +17,7 @@ limitations under the License. package filters import ( + "context" "fmt" "net/http" "net/http/httptest" @@ -103,6 +104,10 @@ func TestMaxInFlightNonMutating(t *testing.T) { server := createMaxInflightServer(calls, block, &waitForCalls, &waitForCallsMutex, AllowedNonMutatingInflightRequestsNo, 1) defer server.Close() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + StartMaxInFlightWatermarkMaintenance(ctx.Done()) + // These should hang, but not affect accounting. use a query param match for i := 0; i < AllowedNonMutatingInflightRequestsNo; i++ { // These should hang waiting on block... @@ -183,6 +188,10 @@ func TestMaxInFlightMutating(t *testing.T) { server := createMaxInflightServer(calls, block, &waitForCalls, &waitForCallsMutex, 1, AllowedMutatingInflightRequestsNo) defer server.Close() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + StartMaxInFlightWatermarkMaintenance(ctx.Done()) + // These should hang and be accounted, i.e. saturate the server for i := 0; i < AllowedMutatingInflightRequestsNo; i++ { // These should hang waiting on block... @@ -275,6 +284,10 @@ func TestMaxInFlightSkipsMasters(t *testing.T) { server := createMaxInflightServer(calls, block, &waitForCalls, &waitForCallsMutex, 1, AllowedMutatingInflightRequestsNo) defer server.Close() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + StartMaxInFlightWatermarkMaintenance(ctx.Done()) + // These should hang and be accounted, i.e. saturate the server for i := 0; i < AllowedMutatingInflightRequestsNo; i++ { // These should hang waiting on block... diff --git a/staging/src/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go b/staging/src/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go index 339b1e2c59bb3..ee182bf04b12b 100644 --- a/staging/src/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go +++ b/staging/src/k8s.io/apiserver/pkg/server/filters/priority-and-fairness.go @@ -76,10 +76,6 @@ func WithPriorityAndFairness( klog.Warningf("priority and fairness support not found, skipping") return handler } - startOnce.Do(func() { - startRecordingUsage(watermark) - startRecordingUsage(waitingMark) - }) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() requestInfo, ok := apirequest.RequestInfoFrom(ctx) @@ -150,3 +146,10 @@ func WithPriorityAndFairness( }) } + +// StartPriorityAndFairnessWatermarkMaintenance starts the goroutines to observe and maintain watermarks for +// priority-and-fairness requests. +func StartPriorityAndFairnessWatermarkMaintenance(stopCh <-chan struct{}) { + startWatermarkMaintenance(watermark, stopCh) + startWatermarkMaintenance(waitingMark, stopCh) +} From ec495b31c9e631696dbce19428321e8b2d53a600 Mon Sep 17 00:00:00 2001 From: Yecheng Fu Date: Wed, 14 Oct 2020 10:47:11 +0800 Subject: [PATCH 008/301] report UnschedulableAndUnresolvable status instead of an error when PVCs can't find bound persistent volumes This is an user error. We should't report an error. --- .../volume/scheduling/scheduler_binder.go | 21 +++++++++++++------ .../scheduling/scheduler_binder_test.go | 3 ++- .../volumebinding/volume_binding_test.go | 2 +- 3 files changed, 18 insertions(+), 8 deletions(-) diff --git a/pkg/controller/volume/scheduling/scheduler_binder.go b/pkg/controller/volume/scheduling/scheduler_binder.go index 10c4caccc131b..68e0f91536d07 100644 --- a/pkg/controller/volume/scheduling/scheduler_binder.go +++ b/pkg/controller/volume/scheduling/scheduler_binder.go @@ -68,6 +68,8 @@ const ( ErrReasonNodeConflict ConflictReason = "node(s) had volume node affinity conflict" // ErrReasonNotEnoughSpace is used when a pod cannot start on a node because not enough storage space is available. ErrReasonNotEnoughSpace = "node(s) did not have enough free storage" + // ErrReasonPVNotExist is used when a PVC can't find the bound persistent volumes" + ErrReasonPVNotExist = "pvc(s) bound to non-existent pv(s)" ) // BindingInfo holds a binding between PV and PVC. @@ -246,6 +248,7 @@ func (b *volumeBinder) FindPodVolumes(pod *v1.Pod, boundClaims, claimsToBind []* unboundVolumesSatisfied := true boundVolumesSatisfied := true sufficientStorage := true + boundPVsFound := true defer func() { if err != nil { return @@ -259,6 +262,9 @@ func (b *volumeBinder) FindPodVolumes(pod *v1.Pod, boundClaims, claimsToBind []* if !sufficientStorage { reasons = append(reasons, ErrReasonNotEnoughSpace) } + if !boundPVsFound { + reasons = append(reasons, ErrReasonPVNotExist) + } }() start := time.Now() @@ -288,7 +294,7 @@ func (b *volumeBinder) FindPodVolumes(pod *v1.Pod, boundClaims, claimsToBind []* // Check PV node affinity on bound volumes if len(boundClaims) > 0 { - boundVolumesSatisfied, err = b.checkBoundClaims(boundClaims, node, podName) + boundVolumesSatisfied, boundPVsFound, err = b.checkBoundClaims(boundClaims, node, podName) if err != nil { return } @@ -762,7 +768,7 @@ func (b *volumeBinder) GetPodVolumes(pod *v1.Pod) (boundClaims []*v1.PersistentV return boundClaims, unboundClaimsDelayBinding, unboundClaimsImmediate, nil } -func (b *volumeBinder) checkBoundClaims(claims []*v1.PersistentVolumeClaim, node *v1.Node, podName string) (bool, error) { +func (b *volumeBinder) checkBoundClaims(claims []*v1.PersistentVolumeClaim, node *v1.Node, podName string) (bool, bool, error) { csiNode, err := b.csiNodeLister.Get(node.Name) if err != nil { // TODO: return the error once CSINode is created by default @@ -773,24 +779,27 @@ func (b *volumeBinder) checkBoundClaims(claims []*v1.PersistentVolumeClaim, node pvName := pvc.Spec.VolumeName pv, err := b.pvCache.GetPV(pvName) if err != nil { - return false, err + if _, ok := err.(*errNotFound); ok { + err = nil + } + return true, false, err } pv, err = b.tryTranslatePVToCSI(pv, csiNode) if err != nil { - return false, err + return false, true, err } err = volumeutil.CheckNodeAffinity(pv, node.Labels) if err != nil { klog.V(4).Infof("PersistentVolume %q, Node %q mismatch for Pod %q: %v", pvName, node.Name, podName, err) - return false, nil + return false, true, nil } klog.V(5).Infof("PersistentVolume %q, Node %q matches for Pod %q", pvName, node.Name, podName) } klog.V(4).Infof("All bound volumes for Pod %q match with Node %q", podName, node.Name) - return true, nil + return true, true, nil } // findMatchingVolumes tries to find matching volumes for given claims, diff --git a/pkg/controller/volume/scheduling/scheduler_binder_test.go b/pkg/controller/volume/scheduling/scheduler_binder_test.go index 93815e8f49803..bb14291597418 100644 --- a/pkg/controller/volume/scheduling/scheduler_binder_test.go +++ b/pkg/controller/volume/scheduling/scheduler_binder_test.go @@ -880,7 +880,8 @@ func TestFindPodVolumesWithoutProvisioning(t *testing.T) { }, "bound-pvc,pv-not-exists": { podPVCs: []*v1.PersistentVolumeClaim{boundPVC}, - shouldFail: true, + shouldFail: false, + reasons: ConflictReasons{ErrReasonPVNotExist}, }, "prebound-pvc": { podPVCs: []*v1.PersistentVolumeClaim{preboundPVC}, diff --git a/pkg/scheduler/framework/plugins/volumebinding/volume_binding_test.go b/pkg/scheduler/framework/plugins/volumebinding/volume_binding_test.go index 14695cdb922c1..2866b0504c8f7 100644 --- a/pkg/scheduler/framework/plugins/volumebinding/volume_binding_test.go +++ b/pkg/scheduler/framework/plugins/volumebinding/volume_binding_test.go @@ -227,7 +227,7 @@ func TestVolumeBinding(t *testing.T) { claimsToBind: []*v1.PersistentVolumeClaim{}, podVolumesByNode: map[string]*scheduling.PodVolumes{}, }, - wantFilterStatus: framework.NewStatus(framework.Error, `could not find v1.PersistentVolume "pv-a"`), + wantFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable, `pvc(s) bound to non-existent pv(s)`), }, } From 67a97e04c8adee576ca4962dc03b0289db23790a Mon Sep 17 00:00:00 2001 From: SataQiu <1527062125@qq.com> Date: Fri, 6 Nov 2020 17:10:45 +0800 Subject: [PATCH 009/301] fix the panic when kubelet registers if a node object already exists with no Status.Capacity or Status.Allocatable Signed-off-by: SataQiu <1527062125@qq.com> --- pkg/kubelet/kubelet_node_status.go | 27 +- pkg/kubelet/kubelet_node_status_test.go | 327 +++++++++++++++++++++++- 2 files changed, 344 insertions(+), 10 deletions(-) diff --git a/pkg/kubelet/kubelet_node_status.go b/pkg/kubelet/kubelet_node_status.go index bb4a7e379d305..32b4c178917f5 100644 --- a/pkg/kubelet/kubelet_node_status.go +++ b/pkg/kubelet/kubelet_node_status.go @@ -126,7 +126,7 @@ func (kl *Kubelet) tryRegisterWithAPIServer(node *v1.Node) bool { // reconcileHugePageResource will update huge page capacity for each page size and remove huge page sizes no longer supported func (kl *Kubelet) reconcileHugePageResource(initialNode, existingNode *v1.Node) bool { - requiresUpdate := false + requiresUpdate := updateDefaultResources(initialNode, existingNode) supportedHugePageResources := sets.String{} for resourceName := range initialNode.Status.Capacity { @@ -173,7 +173,7 @@ func (kl *Kubelet) reconcileHugePageResource(initialNode, existingNode *v1.Node) // Zeros out extended resource capacity during reconciliation. func (kl *Kubelet) reconcileExtendedResource(initialNode, node *v1.Node) bool { - requiresUpdate := false + requiresUpdate := updateDefaultResources(initialNode, node) // Check with the device manager to see if node has been recreated, in which case extended resources should be zeroed until they are available if kl.containerManager.ShouldResetExtendedResourceCapacity() { for k := range node.Status.Capacity { @@ -188,6 +188,29 @@ func (kl *Kubelet) reconcileExtendedResource(initialNode, node *v1.Node) bool { return requiresUpdate } +// updateDefaultResources will set the default resources on the existing node according to the initial node +func updateDefaultResources(initialNode, existingNode *v1.Node) bool { + requiresUpdate := false + if existingNode.Status.Capacity == nil { + if initialNode.Status.Capacity != nil { + existingNode.Status.Capacity = initialNode.Status.Capacity.DeepCopy() + requiresUpdate = true + } else { + existingNode.Status.Capacity = make(map[v1.ResourceName]resource.Quantity) + } + } + + if existingNode.Status.Allocatable == nil { + if initialNode.Status.Allocatable != nil { + existingNode.Status.Allocatable = initialNode.Status.Allocatable.DeepCopy() + requiresUpdate = true + } else { + existingNode.Status.Allocatable = make(map[v1.ResourceName]resource.Quantity) + } + } + return requiresUpdate +} + // updateDefaultLabels will set the default labels on the node func (kl *Kubelet) updateDefaultLabels(initialNode, existingNode *v1.Node) bool { defaultLabels := []string{ diff --git a/pkg/kubelet/kubelet_node_status_test.go b/pkg/kubelet/kubelet_node_status_test.go index ba03c18e9c8a8..a3d6e9de6390b 100644 --- a/pkg/kubelet/kubelet_node_status_test.go +++ b/pkg/kubelet/kubelet_node_status_test.go @@ -1144,6 +1144,13 @@ func TestRegisterWithApiServer(t *testing.T) { }, nil }) + kubeClient.AddReactor("patch", "nodes", func(action core.Action) (bool, runtime.Object, error) { + if action.GetSubresource() == "status" { + return true, nil, nil + } + return notImplemented(action) + }) + addNotImplatedReaction(kubeClient) machineInfo := &cadvisorapi.MachineInfo{ @@ -1700,6 +1707,216 @@ func TestUpdateDefaultLabels(t *testing.T) { } } +func TestUpdateDefaultResources(t *testing.T) { + cases := []struct { + name string + initialNode *v1.Node + existingNode *v1.Node + expectedNode *v1.Node + needsUpdate bool + }{ + { + name: "no update needed when capacity and allocatable of the existing node are not nil", + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + existingNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + needsUpdate: false, + }, { + name: "no update needed when capacity and allocatable of the initial node are nil", + initialNode: &v1.Node{}, + existingNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + needsUpdate: false, + }, { + name: "update needed when capacity and allocatable of the existing node are nil and capacity and allocatable of the initial node are not nil", + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + existingNode: &v1.Node{}, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + needsUpdate: true, + }, { + name: "update needed when capacity of the existing node is nil and capacity of the initial node is not nil", + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + existingNode: &v1.Node{ + Status: v1.NodeStatus{ + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + needsUpdate: true, + }, { + name: "update needed when allocatable of the existing node is nil and allocatable of the initial node is not nil", + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + existingNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, + needsUpdate: true, + }, { + name: "no update needed but capacity and allocatable of existing node should be initialized", + initialNode: &v1.Node{}, + existingNode: &v1.Node{}, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{}, + Allocatable: v1.ResourceList{}, + }, + }, + needsUpdate: false, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(T *testing.T) { + needsUpdate := updateDefaultResources(tc.initialNode, tc.existingNode) + assert.Equal(t, tc.needsUpdate, needsUpdate, tc.name) + assert.Equal(t, tc.expectedNode, tc.existingNode, tc.name) + }) + } +} + func TestReconcileHugePageResource(t *testing.T) { testKubelet := newTestKubelet(t, false /* controllerAttachDetachEnabled */) hugePageResourceName64Ki := v1.ResourceName("hugepages-64Ki") @@ -1934,6 +2151,49 @@ func TestReconcileHugePageResource(t *testing.T) { }, }, }, + }, { + name: "not panic when capacity or allocatable of existing node is nil", + testKubelet: testKubelet, + needsUpdate: true, + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + hugePageResourceName2Mi: resource.MustParse("100Mi"), + hugePageResourceName64Ki: *resource.NewQuantity(0, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + hugePageResourceName2Mi: resource.MustParse("100Mi"), + hugePageResourceName64Ki: *resource.NewQuantity(0, resource.BinarySI), + }, + }, + }, + existingNode: &v1.Node{ + Status: v1.NodeStatus{}, + }, + expectedNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + hugePageResourceName2Mi: resource.MustParse("100Mi"), + hugePageResourceName64Ki: *resource.NewQuantity(0, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + hugePageResourceName2Mi: resource.MustParse("100Mi"), + hugePageResourceName64Ki: *resource.NewQuantity(0, resource.BinarySI), + }, + }, + }, }, } @@ -1960,6 +2220,7 @@ func TestReconcileExtendedResource(t *testing.T) { cases := []struct { name string testKubelet *TestKubelet + initialNode *v1.Node existingNode *v1.Node expectedNode *v1.Node needsUpdate bool @@ -1967,6 +2228,20 @@ func TestReconcileExtendedResource(t *testing.T) { { name: "no update needed without extended resource", testKubelet: testKubelet, + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + }, + }, + }, existingNode: &v1.Node{ Status: v1.NodeStatus{ Capacity: v1.ResourceList{ @@ -1998,19 +2273,41 @@ func TestReconcileExtendedResource(t *testing.T) { needsUpdate: false, }, { - name: "extended resource capacity is not zeroed due to presence of checkpoint file", - testKubelet: testKubelet, + name: "extended resource capacity is zeroed", + testKubelet: testKubeletNoReset, + initialNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(2), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(10), resource.DecimalSI), + }, + Allocatable: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(2), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(10), resource.DecimalSI), + }, + }, + }, existingNode: &v1.Node{ Status: v1.NodeStatus{ Capacity: v1.ResourceList{ v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(2), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(10), resource.DecimalSI), }, Allocatable: v1.ResourceList{ v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(2), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(10), resource.DecimalSI), }, }, }, @@ -2020,20 +2317,24 @@ func TestReconcileExtendedResource(t *testing.T) { v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(0), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(0), resource.DecimalSI), }, Allocatable: v1.ResourceList{ v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(0), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(0), resource.DecimalSI), }, }, }, - needsUpdate: false, + needsUpdate: true, }, { - name: "extended resource capacity is zeroed", - testKubelet: testKubeletNoReset, - existingNode: &v1.Node{ + name: "not panic when allocatable of existing node is nil", + testKubelet: testKubelet, + initialNode: &v1.Node{ Status: v1.NodeStatus{ Capacity: v1.ResourceList{ v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), @@ -2051,6 +2352,17 @@ func TestReconcileExtendedResource(t *testing.T) { }, }, }, + existingNode: &v1.Node{ + Status: v1.NodeStatus{ + Capacity: v1.ResourceList{ + v1.ResourceCPU: *resource.NewMilliQuantity(2000, resource.DecimalSI), + v1.ResourceMemory: *resource.NewQuantity(10e9, resource.BinarySI), + v1.ResourceEphemeralStorage: *resource.NewQuantity(5000, resource.BinarySI), + extendedResourceName1: *resource.NewQuantity(int64(2), resource.DecimalSI), + extendedResourceName2: *resource.NewQuantity(int64(10), resource.DecimalSI), + }, + }, + }, expectedNode: &v1.Node{ Status: v1.NodeStatus{ Capacity: v1.ResourceList{ @@ -2076,9 +2388,8 @@ func TestReconcileExtendedResource(t *testing.T) { for _, tc := range cases { defer testKubelet.Cleanup() kubelet := testKubelet.kubelet - initialNode := &v1.Node{} - needsUpdate := kubelet.reconcileExtendedResource(initialNode, tc.existingNode) + needsUpdate := kubelet.reconcileExtendedResource(tc.initialNode, tc.existingNode) assert.Equal(t, tc.needsUpdate, needsUpdate, tc.name) assert.Equal(t, tc.expectedNode, tc.existingNode, tc.name) } From 41d951096961cd59465ec13199713fac08d2e942 Mon Sep 17 00:00:00 2001 From: ialidzhikov Date: Sun, 30 Aug 2020 21:52:41 +0300 Subject: [PATCH 010/301] Update max data disk count with new instance types Signed-off-by: ialidzhikov more update --- .../azure_dd/azure_dd_max_disk_count.go | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/pkg/volume/azure_dd/azure_dd_max_disk_count.go b/pkg/volume/azure_dd/azure_dd_max_disk_count.go index 8a41a46e864c5..0319e99432cb1 100644 --- a/pkg/volume/azure_dd/azure_dd_max_disk_count.go +++ b/pkg/volume/azure_dd/azure_dd_max_disk_count.go @@ -74,7 +74,9 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_D16DS_V4": 32, "STANDARD_D16D_V4": 32, "STANDARD_D16S_V3": 32, + "STANDARD_D16S_V4": 32, "STANDARD_D16_V3": 32, + "STANDARD_D16_V4": 32, "STANDARD_D1_V2": 4, "STANDARD_D2": 8, "STANDARD_D2AS_V4": 4, @@ -82,16 +84,20 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_D2DS_V4": 4, "STANDARD_D2D_V4": 4, "STANDARD_D2S_V3": 4, + "STANDARD_D2S_V4": 4, "STANDARD_D2_V2": 8, "STANDARD_D2_V2_PROMO": 8, "STANDARD_D2_V3": 4, + "STANDARD_D2_V4": 4, "STANDARD_D3": 16, "STANDARD_D32AS_V4": 32, "STANDARD_D32A_V4": 32, "STANDARD_D32DS_V4": 32, "STANDARD_D32D_V4": 32, "STANDARD_D32S_V3": 32, + "STANDARD_D32S_V4": 32, "STANDARD_D32_V3": 32, + "STANDARD_D32_V4": 32, "STANDARD_D3_V2": 16, "STANDARD_D3_V2_PROMO": 16, "STANDARD_D4": 32, @@ -100,15 +106,19 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_D48DS_V4": 32, "STANDARD_D48D_V4": 32, "STANDARD_D48S_V3": 32, + "STANDARD_D48S_V4": 32, "STANDARD_D48_V3": 32, + "STANDARD_D48_V4": 32, "STANDARD_D4AS_V4": 8, "STANDARD_D4A_V4": 8, "STANDARD_D4DS_V4": 8, "STANDARD_D4D_V4": 8, "STANDARD_D4S_V3": 8, + "STANDARD_D4S_V4": 8, "STANDARD_D4_V2": 32, "STANDARD_D4_V2_PROMO": 32, "STANDARD_D4_V3": 8, + "STANDARD_D4_V4": 8, "STANDARD_D5_V2": 64, "STANDARD_D5_V2_PROMO": 64, "STANDARD_D64AS_V4": 32, @@ -116,13 +126,17 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_D64DS_V4": 32, "STANDARD_D64D_V4": 32, "STANDARD_D64S_V3": 32, + "STANDARD_D64S_V4": 32, "STANDARD_D64_V3": 32, + "STANDARD_D64_V4": 32, "STANDARD_D8AS_V4": 16, "STANDARD_D8A_V4": 16, "STANDARD_D8DS_V4": 16, "STANDARD_D8D_V4": 16, "STANDARD_D8S_V3": 16, + "STANDARD_D8S_V4": 16, "STANDARD_D8_V3": 16, + "STANDARD_D8_V4": 16, "STANDARD_D96AS_V4": 32, "STANDARD_D96A_V4": 32, "STANDARD_DC1S_V2": 1, @@ -130,6 +144,7 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_DC2S_V2": 2, "STANDARD_DC4S": 4, "STANDARD_DC4S_V2": 4, + "STANDARD_DC8S": 8, "STANDARD_DC8_V2": 8, "STANDARD_DS11-1_V2": 8, "STANDARD_DS11": 8, @@ -164,55 +179,82 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_DS4_V2_PROMO": 32, "STANDARD_DS5_V2": 64, "STANDARD_DS5_V2_PROMO": 64, + "STANDARD_E16-4AS_V4": 32, "STANDARD_E16-4DS_V4": 32, "STANDARD_E16-4S_V3": 32, + "STANDARD_E16-4S_V4": 32, + "STANDARD_E16-8AS_V4": 32, "STANDARD_E16-8DS_V4": 32, "STANDARD_E16-8S_V3": 32, + "STANDARD_E16-8S_V4": 32, "STANDARD_E16AS_V4": 32, "STANDARD_E16A_V4": 32, "STANDARD_E16DS_V4": 32, "STANDARD_E16D_V4": 32, "STANDARD_E16S_V3": 32, + "STANDARD_E16S_V4": 32, "STANDARD_E16_V3": 32, + "STANDARD_E16_V4": 32, "STANDARD_E20AS_V4": 32, "STANDARD_E20A_V4": 32, "STANDARD_E20DS_V4": 32, "STANDARD_E20D_V4": 32, "STANDARD_E20S_V3": 32, + "STANDARD_E20S_V4": 32, "STANDARD_E20_V3": 32, + "STANDARD_E20_V4": 32, "STANDARD_E2AS_V4": 4, "STANDARD_E2A_V4": 4, "STANDARD_E2DS_V4": 4, "STANDARD_E2D_V4": 4, "STANDARD_E2S_V3": 4, + "STANDARD_E2S_V4": 4, "STANDARD_E2_V3": 4, + "STANDARD_E2_V4": 4, + "STANDARD_E32-16AS_V4": 32, "STANDARD_E32-16DS_V4": 32, "STANDARD_E32-16S_V3": 32, + "STANDARD_E32-16S_V4": 32, + "STANDARD_E32-8AS_V4": 32, "STANDARD_E32-8DS_V4": 32, "STANDARD_E32-8S_V3": 32, + "STANDARD_E32-8S_V4": 32, "STANDARD_E32AS_V4": 32, "STANDARD_E32A_V4": 32, "STANDARD_E32DS_V4": 32, "STANDARD_E32D_V4": 32, "STANDARD_E32S_V3": 32, + "STANDARD_E32S_V4": 32, "STANDARD_E32_V3": 32, + "STANDARD_E32_V4": 32, + "STANDARD_E4-2AS_V4": 8, "STANDARD_E4-2DS_V4": 8, "STANDARD_E4-2S_V3": 8, + "STANDARD_E4-2S_V4": 8, "STANDARD_E48AS_V4": 32, "STANDARD_E48A_V4": 32, "STANDARD_E48DS_V4": 32, "STANDARD_E48D_V4": 32, "STANDARD_E48S_V3": 32, + "STANDARD_E48S_V4": 32, "STANDARD_E48_V3": 32, + "STANDARD_E48_V4": 32, "STANDARD_E4AS_V4": 8, "STANDARD_E4A_V4": 8, "STANDARD_E4DS_V4": 8, "STANDARD_E4D_V4": 8, "STANDARD_E4S_V3": 8, + "STANDARD_E4S_V4": 8, "STANDARD_E4_V3": 8, + "STANDARD_E4_V4": 8, + "STANDARD_E64-16AS_V4": 32, "STANDARD_E64-16DS_V4": 32, "STANDARD_E64-16S_V3": 32, + "STANDARD_E64-16S_V4": 32, + "STANDARD_E64-32AS_V4": 32, + "STANDARD_E64-32DS_V4": 32, "STANDARD_E64-32S_V3": 32, + "STANDARD_E64-32S_V4": 32, "STANDARD_E64AS_V4": 32, "STANDARD_E64A_V4": 32, "STANDARD_E64DS_V4": 32, @@ -220,17 +262,29 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_E64IS_V3": 32, "STANDARD_E64I_V3": 32, "STANDARD_E64S_V3": 32, + "STANDARD_E64S_V4": 32, "STANDARD_E64_V3": 32, + "STANDARD_E64_V4": 32, + "STANDARD_E80IDS_V4": 32, + "STANDARD_E80IS_V4": 32, + "STANDARD_E8-2AS_V4": 16, "STANDARD_E8-2DS_V4": 16, "STANDARD_E8-2S_V3": 16, + "STANDARD_E8-2S_V4": 16, + "STANDARD_E8-4AS_V4": 16, "STANDARD_E8-4DS_V4": 16, "STANDARD_E8-4S_V3": 16, + "STANDARD_E8-4S_V4": 16, "STANDARD_E8AS_V4": 16, "STANDARD_E8A_V4": 16, "STANDARD_E8DS_V4": 16, "STANDARD_E8D_V4": 16, "STANDARD_E8S_V3": 16, + "STANDARD_E8S_V4": 16, "STANDARD_E8_V3": 16, + "STANDARD_E8_V4": 16, + "STANDARD_E96-24AS_V4": 32, + "STANDARD_E96-48AS_V4": 32, "STANDARD_E96AS_V4": 32, "STANDARD_E96A_V4": 32, "STANDARD_F1": 4, @@ -324,6 +378,7 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_NC12_PROMO": 48, "STANDARD_NC12S_V2": 24, "STANDARD_NC12S_V3": 24, + "STANDARD_NC16AS_T4_V3": 32, "STANDARD_NC24": 64, "STANDARD_NC24_PROMO": 64, "STANDARD_NC24R": 64, @@ -332,10 +387,13 @@ var maxDataDiskCountMap = map[string]int64{ "STANDARD_NC24RS_V3": 32, "STANDARD_NC24S_V2": 32, "STANDARD_NC24S_V3": 32, + "STANDARD_NC4AS_T4_V3": 8, "STANDARD_NC6": 24, + "STANDARD_NC64AS_T4_V3": 32, "STANDARD_NC6_PROMO": 24, "STANDARD_NC6S_V2": 12, "STANDARD_NC6S_V3": 12, + "STANDARD_NC8AS_T4_V3": 16, "STANDARD_ND12S": 24, "STANDARD_ND24RS": 32, "STANDARD_ND24S": 32, From 4938f661f0ba513cbde38f5985230519106944cb Mon Sep 17 00:00:00 2001 From: Maciej Szulik Date: Tue, 8 Sep 2020 10:26:10 +0200 Subject: [PATCH 011/301] Use namespace flag passed to RunKubectl* methods --- test/e2e/apps/statefulset.go | 12 +- test/e2e/examples.go | 13 +- test/e2e/framework/ingress/ingress_utils.go | 10 +- test/e2e/framework/kubectl/kubectl_utils.go | 3 + test/e2e/framework/util.go | 12 +- test/e2e/kubectl/kubectl.go | 197 +++++++++----------- test/e2e/storage/testsuites/subpath.go | 2 +- test/e2e/storage/vsphere/vsphere_utils.go | 6 +- test/e2e/upgrades/cassandra.go | 2 +- test/e2e/upgrades/etcd.go | 2 +- test/e2e/upgrades/mysql.go | 2 +- 11 files changed, 116 insertions(+), 145 deletions(-) diff --git a/test/e2e/apps/statefulset.go b/test/e2e/apps/statefulset.go index f89d5cc5f1c7f..b136689fb1ca9 100644 --- a/test/e2e/apps/statefulset.go +++ b/test/e2e/apps/statefulset.go @@ -981,18 +981,16 @@ func (z *zookeeperTester) deploy(ns string) *appsv1.StatefulSet { func (z *zookeeperTester) write(statefulPodIndex int, kv map[string]string) { name := fmt.Sprintf("%v-%d", z.ss.Name, statefulPodIndex) - ns := fmt.Sprintf("--namespace=%v", z.ss.Namespace) for k, v := range kv { cmd := fmt.Sprintf("/opt/zookeeper/bin/zkCli.sh create /%v %v", k, v) - framework.Logf(framework.RunKubectlOrDie(z.ss.Namespace, "exec", ns, name, "--", "/bin/sh", "-c", cmd)) + framework.Logf(framework.RunKubectlOrDie(z.ss.Namespace, "exec", name, "--", "/bin/sh", "-c", cmd)) } } func (z *zookeeperTester) read(statefulPodIndex int, key string) string { name := fmt.Sprintf("%v-%d", z.ss.Name, statefulPodIndex) - ns := fmt.Sprintf("--namespace=%v", z.ss.Namespace) cmd := fmt.Sprintf("/opt/zookeeper/bin/zkCli.sh get /%v", key) - return lastLine(framework.RunKubectlOrDie(z.ss.Namespace, "exec", ns, name, "--", "/bin/sh", "-c", cmd)) + return lastLine(framework.RunKubectlOrDie(z.ss.Namespace, "exec", name, "--", "/bin/sh", "-c", cmd)) } type mysqlGaleraTester struct { @@ -1009,7 +1007,7 @@ func (m *mysqlGaleraTester) mysqlExec(cmd, ns, podName string) string { // TODO: Find a readiness probe for mysql that guarantees writes will // succeed and ditch retries. Current probe only reads, so there's a window // for a race. - return kubectlExecWithRetries(ns, fmt.Sprintf("--namespace=%v", ns), "exec", podName, "--", "/bin/sh", "-c", cmd) + return kubectlExecWithRetries(ns, "exec", podName, "--", "/bin/sh", "-c", cmd) } func (m *mysqlGaleraTester) deploy(ns string) *appsv1.StatefulSet { @@ -1049,7 +1047,7 @@ func (m *redisTester) name() string { func (m *redisTester) redisExec(cmd, ns, podName string) string { cmd = fmt.Sprintf("/opt/redis/redis-cli -h %v %v", podName, cmd) - return framework.RunKubectlOrDie(ns, fmt.Sprintf("--namespace=%v", ns), "exec", podName, "--", "/bin/sh", "-c", cmd) + return framework.RunKubectlOrDie(ns, "exec", podName, "--", "/bin/sh", "-c", cmd) } func (m *redisTester) deploy(ns string) *appsv1.StatefulSet { @@ -1080,7 +1078,7 @@ func (c *cockroachDBTester) name() string { func (c *cockroachDBTester) cockroachDBExec(cmd, ns, podName string) string { cmd = fmt.Sprintf("/cockroach/cockroach sql --insecure --host %s.cockroachdb -e \"%v\"", podName, cmd) - return framework.RunKubectlOrDie(ns, fmt.Sprintf("--namespace=%v", ns), "exec", podName, "--", "/bin/sh", "-c", cmd) + return framework.RunKubectlOrDie(ns, "exec", podName, "--", "/bin/sh", "-c", cmd) } func (c *cockroachDBTester) deploy(ns string) *appsv1.StatefulSet { diff --git a/test/e2e/examples.go b/test/e2e/examples.go index 4e030bdb2404b..599725728d58c 100644 --- a/test/e2e/examples.go +++ b/test/e2e/examples.go @@ -68,10 +68,9 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() { test := "test/fixtures/doc-yaml/user-guide/liveness" execYaml := readFile(test, "exec-liveness.yaml.in") httpYaml := readFile(test, "http-liveness.yaml.in") - nsFlag := fmt.Sprintf("--namespace=%v", ns) - framework.RunKubectlOrDieInput(ns, execYaml, "create", "-f", "-", nsFlag) - framework.RunKubectlOrDieInput(ns, httpYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, execYaml, "create", "-f", "-") + framework.RunKubectlOrDieInput(ns, httpYaml, "create", "-f", "-") // Since both containers start rapidly, we can easily run this test in parallel. var wg sync.WaitGroup @@ -117,12 +116,11 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() { secretYaml := readFile(test, "secret.yaml") podYaml := readFile(test, "secret-pod.yaml.in") - nsFlag := fmt.Sprintf("--namespace=%v", ns) podName := "secret-test-pod" ginkgo.By("creating secret and pod") - framework.RunKubectlOrDieInput(ns, secretYaml, "create", "-f", "-", nsFlag) - framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, secretYaml, "create", "-f", "-") + framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-") err := e2epod.WaitForPodNoLongerRunningInNamespace(c, podName, ns) framework.ExpectNoError(err) @@ -136,11 +134,10 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() { ginkgo.It("should create a pod that prints his name and namespace", func() { test := "test/fixtures/doc-yaml/user-guide/downward-api" podYaml := readFile(test, "dapi-pod.yaml.in") - nsFlag := fmt.Sprintf("--namespace=%v", ns) podName := "dapi-test-pod" ginkgo.By("creating the pod") - framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-") err := e2epod.WaitForPodNoLongerRunningInNamespace(c, podName, ns) framework.ExpectNoError(err) diff --git a/test/e2e/framework/ingress/ingress_utils.go b/test/e2e/framework/ingress/ingress_utils.go index ebe8d096826cf..8328e2a299594 100644 --- a/test/e2e/framework/ingress/ingress_utils.go +++ b/test/e2e/framework/ingress/ingress_utils.go @@ -460,10 +460,10 @@ func (j *TestJig) CreateIngress(manifestPath, ns string, ingAnnotations map[stri } j.Logger.Infof("creating replication controller") - framework.RunKubectlOrDieInput(ns, read("rc.yaml"), "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, read("rc.yaml"), "create", "-f", "-") j.Logger.Infof("creating service") - framework.RunKubectlOrDieInput(ns, read("svc.yaml"), "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, read("svc.yaml"), "create", "-f", "-") if len(svcAnnotations) > 0 { svcList, err := j.Client.CoreV1().Services(ns).List(context.TODO(), metav1.ListOptions{}) framework.ExpectNoError(err) @@ -476,7 +476,7 @@ func (j *TestJig) CreateIngress(manifestPath, ns string, ingAnnotations map[stri if exists("secret.yaml") { j.Logger.Infof("creating secret") - framework.RunKubectlOrDieInput(ns, read("secret.yaml"), "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, read("secret.yaml"), "create", "-f", "-") } j.Logger.Infof("Parsing ingress from %v", filepath.Join(manifestPath, "ing.yaml")) @@ -569,7 +569,7 @@ func (j *TestJig) runUpdate(ing *networkingv1beta1.Ingress) (*networkingv1beta1. func DescribeIng(ns string) { framework.Logf("\nOutput of kubectl describe ing:\n") desc, _ := framework.RunKubectl( - ns, "describe", "ing", fmt.Sprintf("--namespace=%v", ns)) + ns, "describe", "ing") framework.Logf(desc) } @@ -1034,7 +1034,7 @@ func (cont *NginxIngressController) Init() { } framework.Logf("initializing nginx ingress controller") - framework.RunKubectlOrDieInput(cont.Ns, read("rc.yaml"), "create", "-f", "-", fmt.Sprintf("--namespace=%v", cont.Ns)) + framework.RunKubectlOrDieInput(cont.Ns, read("rc.yaml"), "create", "-f", "-") rc, err := cont.Client.CoreV1().ReplicationControllers(cont.Ns).Get(context.TODO(), "nginx-ingress-controller", metav1.GetOptions{}) framework.ExpectNoError(err) diff --git a/test/e2e/framework/kubectl/kubectl_utils.go b/test/e2e/framework/kubectl/kubectl_utils.go index 0449fc6404976..d6765d23b4733 100644 --- a/test/e2e/framework/kubectl/kubectl_utils.go +++ b/test/e2e/framework/kubectl/kubectl_utils.go @@ -86,6 +86,9 @@ func (tk *TestKubeconfig) KubectlCmd(args ...string) *exec.Cmd { fmt.Sprintf("--client-key=%s", filepath.Join(tk.CertDir, "kubecfg.key"))) } } + if tk.Namespace != "" { + defaultArgs = append(defaultArgs, fmt.Sprintf("--namespace=%s", tk.Namespace)) + } kubectlArgs := append(defaultArgs, args...) //We allow users to specify path to kubectl, so you can test either "kubectl" or "cluster/kubectl.sh" diff --git a/test/e2e/framework/util.go b/test/e2e/framework/util.go index 2f8376d8e0734..5b8c09d04ee83 100644 --- a/test/e2e/framework/util.go +++ b/test/e2e/framework/util.go @@ -1066,13 +1066,13 @@ func NodeHasTaint(c clientset.Interface, nodeName string, taint *v1.Taint) (bool // RunHostCmd runs the given cmd in the context of the given pod using `kubectl exec` // inside of a shell. func RunHostCmd(ns, name, cmd string) (string, error) { - return RunKubectl(ns, "exec", fmt.Sprintf("--namespace=%v", ns), name, "--", "/bin/sh", "-x", "-c", cmd) + return RunKubectl(ns, "exec", name, "--", "/bin/sh", "-x", "-c", cmd) } // RunHostCmdWithFullOutput runs the given cmd in the context of the given pod using `kubectl exec` // inside of a shell. It will also return the command's stderr. func RunHostCmdWithFullOutput(ns, name, cmd string) (string, string, error) { - return RunKubectlWithFullOutput(ns, "exec", fmt.Sprintf("--namespace=%v", ns), name, "--", "/bin/sh", "-x", "-c", cmd) + return RunKubectlWithFullOutput(ns, "exec", name, "--", "/bin/sh", "-x", "-c", cmd) } // RunHostCmdOrDie calls RunHostCmd and dies on error. @@ -1150,7 +1150,7 @@ func AllNodesReady(c clientset.Interface, timeout time.Duration) error { // LookForStringInLog looks for the given string in the log of a specific pod container func LookForStringInLog(ns, podName, container, expectedString string, timeout time.Duration) (result string, err error) { return lookForString(expectedString, timeout, func() string { - return RunKubectlOrDie(ns, "logs", podName, container, fmt.Sprintf("--namespace=%v", ns)) + return RunKubectlOrDie(ns, "logs", podName, container) }) } @@ -1276,7 +1276,7 @@ func GetAllMasterAddresses(c clientset.Interface) []string { // CreateEmptyFileOnPod creates empty file at given path on the pod. // TODO(alejandrox1): move to subpkg pod once kubectl methods have been refactored. func CreateEmptyFileOnPod(namespace string, podName string, filePath string) error { - _, err := RunKubectl(namespace, "exec", fmt.Sprintf("--namespace=%s", namespace), podName, "--", "/bin/sh", "-c", fmt.Sprintf("touch %s", filePath)) + _, err := RunKubectl(namespace, "exec", podName, "--", "/bin/sh", "-c", fmt.Sprintf("touch %s", filePath)) return err } @@ -1284,10 +1284,10 @@ func CreateEmptyFileOnPod(namespace string, podName string, filePath string) err func DumpDebugInfo(c clientset.Interface, ns string) { sl, _ := c.CoreV1().Pods(ns).List(context.TODO(), metav1.ListOptions{LabelSelector: labels.Everything().String()}) for _, s := range sl.Items { - desc, _ := RunKubectl(ns, "describe", "po", s.Name, fmt.Sprintf("--namespace=%v", ns)) + desc, _ := RunKubectl(ns, "describe", "po", s.Name) Logf("\nOutput of kubectl describe %v:\n%v", s.Name, desc) - l, _ := RunKubectl(ns, "logs", s.Name, fmt.Sprintf("--namespace=%v", ns), "--tail=100") + l, _ := RunKubectl(ns, "logs", s.Name, "--tail=100") Logf("\nLast 100 log lines of %v:\n%v", s.Name, l) } } diff --git a/test/e2e/kubectl/kubectl.go b/test/e2e/kubectl/kubectl.go index 3107b6f26e57f..1127900a47bed 100644 --- a/test/e2e/kubectl/kubectl.go +++ b/test/e2e/kubectl/kubectl.go @@ -322,7 +322,7 @@ var _ = SIGDescribe("Kubectl client", func() { defer cleanupKubectlInputs(nautilus, ns, updateDemoSelector) ginkgo.By("creating a replication controller") - framework.RunKubectlOrDieInput(ns, nautilus, "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, nautilus, "create", "-f", "-") validateController(c, nautilusImage, 2, "update-demo", updateDemoSelector, getUDData("nautilus.jpg", ns), ns) }) @@ -335,15 +335,15 @@ var _ = SIGDescribe("Kubectl client", func() { defer cleanupKubectlInputs(nautilus, ns, updateDemoSelector) ginkgo.By("creating a replication controller") - framework.RunKubectlOrDieInput(ns, nautilus, "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, nautilus, "create", "-f", "-") validateController(c, nautilusImage, 2, "update-demo", updateDemoSelector, getUDData("nautilus.jpg", ns), ns) ginkgo.By("scaling down the replication controller") debugDiscovery() - framework.RunKubectlOrDie(ns, "scale", "rc", "update-demo-nautilus", "--replicas=1", "--timeout=5m", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDie(ns, "scale", "rc", "update-demo-nautilus", "--replicas=1", "--timeout=5m") validateController(c, nautilusImage, 1, "update-demo", updateDemoSelector, getUDData("nautilus.jpg", ns), ns) ginkgo.By("scaling up the replication controller") debugDiscovery() - framework.RunKubectlOrDie(ns, "scale", "rc", "update-demo-nautilus", "--replicas=2", "--timeout=5m", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDie(ns, "scale", "rc", "update-demo-nautilus", "--replicas=2", "--timeout=5m") validateController(c, nautilusImage, 2, "update-demo", updateDemoSelector, getUDData("nautilus.jpg", ns), ns) }) }) @@ -380,7 +380,7 @@ var _ = SIGDescribe("Kubectl client", func() { ginkgo.By("creating all guestbook components") forEachGBFile(func(contents string) { framework.Logf(contents) - framework.RunKubectlOrDieInput(ns, contents, "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, contents, "create", "-f", "-") }) ginkgo.By("validating guestbook app") @@ -393,7 +393,7 @@ var _ = SIGDescribe("Kubectl client", func() { ginkgo.BeforeEach(func() { ginkgo.By(fmt.Sprintf("creating the pod from %v", podYaml)) podYaml = commonutils.SubstituteImageName(string(readTestFileOrDie("pod-with-readiness-probe.yaml.in"))) - framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-", fmt.Sprintf("--namespace=%v", ns)) + framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-") framework.ExpectEqual(e2epod.CheckPodsRunningReady(c, ns, []string{simplePodName}, framework.PodStartTimeout), true) }) ginkgo.AfterEach(func() { @@ -402,7 +402,7 @@ var _ = SIGDescribe("Kubectl client", func() { ginkgo.It("should support exec", func() { ginkgo.By("executing a command in the container") - execOutput := framework.RunKubectlOrDie(ns, "exec", fmt.Sprintf("--namespace=%v", ns), simplePodName, "echo", "running", "in", "container") + execOutput := framework.RunKubectlOrDie(ns, "exec", simplePodName, "echo", "running", "in", "container") if e, a := "running in container", strings.TrimSpace(execOutput); e != a { framework.Failf("Unexpected kubectl exec output. Wanted %q, got %q", e, a) } @@ -412,11 +412,11 @@ var _ = SIGDescribe("Kubectl client", func() { for i := 0; i < len(veryLongData); i++ { veryLongData[i] = 'a' } - execOutput = framework.RunKubectlOrDie(ns, "exec", fmt.Sprintf("--namespace=%v", ns), simplePodName, "echo", string(veryLongData)) + execOutput = framework.RunKubectlOrDie(ns, "exec", simplePodName, "echo", string(veryLongData)) framework.ExpectEqual(string(veryLongData), strings.TrimSpace(execOutput), "Unexpected kubectl exec output") ginkgo.By("executing a command in the container with noninteractive stdin") - execOutput = framework.NewKubectlCommand(ns, "exec", fmt.Sprintf("--namespace=%v", ns), "-i", simplePodName, "cat"). + execOutput = framework.NewKubectlCommand(ns, "exec", "-i", simplePodName, "cat"). WithStdinData("abcd1234"). ExecOrDie(ns) if e, a := "abcd1234", execOutput; e != a { @@ -432,7 +432,7 @@ var _ = SIGDescribe("Kubectl client", func() { defer closer.Close() ginkgo.By("executing a command in the container with pseudo-interactive stdin") - execOutput = framework.NewKubectlCommand(ns, "exec", fmt.Sprintf("--namespace=%v", ns), "-i", simplePodName, "sh"). + execOutput = framework.NewKubectlCommand(ns, "exec", "-i", simplePodName, "sh"). WithStdinReader(r). ExecOrDie(ns) if e, a := "hi", strings.TrimSpace(execOutput); e != a { @@ -442,7 +442,7 @@ var _ = SIGDescribe("Kubectl client", func() { ginkgo.It("should support exec using resource/name", func() { ginkgo.By("executing a command in the container") - execOutput := framework.RunKubectlOrDie(ns, "exec", fmt.Sprintf("--namespace=%v", ns), simplePodResourceName, "echo", "running", "in", "container") + execOutput := framework.RunKubectlOrDie(ns, "exec", simplePodResourceName, "echo", "running", "in", "container") if e, a := "running in container", strings.TrimSpace(execOutput); e != a { framework.Failf("Unexpected kubectl exec output. Wanted %q, got %q", e, a) } @@ -509,30 +509,28 @@ var _ = SIGDescribe("Kubectl client", func() { }) ginkgo.It("should return command exit codes", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) - ginkgo.By("execing into a container with a successful command") - _, err := framework.NewKubectlCommand(ns, nsFlag, "exec", "httpd", "--", "/bin/sh", "-c", "exit 0").Exec() + _, err := framework.NewKubectlCommand(ns, "exec", "httpd", "--", "/bin/sh", "-c", "exit 0").Exec() framework.ExpectNoError(err) ginkgo.By("execing into a container with a failing command") - _, err = framework.NewKubectlCommand(ns, nsFlag, "exec", "httpd", "--", "/bin/sh", "-c", "exit 42").Exec() + _, err = framework.NewKubectlCommand(ns, "exec", "httpd", "--", "/bin/sh", "-c", "exit 42").Exec() ee, ok := err.(uexec.ExitError) framework.ExpectEqual(ok, true) framework.ExpectEqual(ee.ExitStatus(), 42) ginkgo.By("running a successful command") - _, err = framework.NewKubectlCommand(ns, nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=Never", "success", "--", "/bin/sh", "-c", "exit 0").Exec() + _, err = framework.NewKubectlCommand(ns, "run", "-i", "--image="+busyboxImage, "--restart=Never", "success", "--", "/bin/sh", "-c", "exit 0").Exec() framework.ExpectNoError(err) ginkgo.By("running a failing command") - _, err = framework.NewKubectlCommand(ns, nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=Never", "failure-1", "--", "/bin/sh", "-c", "exit 42").Exec() + _, err = framework.NewKubectlCommand(ns, "run", "-i", "--image="+busyboxImage, "--restart=Never", "failure-1", "--", "/bin/sh", "-c", "exit 42").Exec() ee, ok = err.(uexec.ExitError) framework.ExpectEqual(ok, true) framework.ExpectEqual(ee.ExitStatus(), 42) ginkgo.By("running a failing command without --restart=Never") - _, err = framework.NewKubectlCommand(ns, nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=OnFailure", "failure-2", "--", "/bin/sh", "-c", "cat && exit 42"). + _, err = framework.NewKubectlCommand(ns, "run", "-i", "--image="+busyboxImage, "--restart=OnFailure", "failure-2", "--", "/bin/sh", "-c", "cat && exit 42"). WithStdinData("abcd1234"). Exec() ee, ok = err.(uexec.ExitError) @@ -542,7 +540,7 @@ var _ = SIGDescribe("Kubectl client", func() { } ginkgo.By("running a failing command without --restart=Never, but with --rm") - _, err = framework.NewKubectlCommand(ns, nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=OnFailure", "--rm", "failure-3", "--", "/bin/sh", "-c", "cat && exit 42"). + _, err = framework.NewKubectlCommand(ns, "run", "-i", "--image="+busyboxImage, "--restart=OnFailure", "--rm", "failure-3", "--", "/bin/sh", "-c", "cat && exit 42"). WithStdinData("abcd1234"). Exec() ee, ok = err.(uexec.ExitError) @@ -553,18 +551,16 @@ var _ = SIGDescribe("Kubectl client", func() { e2epod.WaitForPodToDisappear(f.ClientSet, ns, "failure-3", labels.Everything(), 2*time.Second, wait.ForeverTestTimeout) ginkgo.By("running a failing command with --leave-stdin-open") - _, err = framework.NewKubectlCommand(ns, nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=Never", "failure-4", "--leave-stdin-open", "--", "/bin/sh", "-c", "exit 42"). + _, err = framework.NewKubectlCommand(ns, "run", "-i", "--image="+busyboxImage, "--restart=Never", "failure-4", "--leave-stdin-open", "--", "/bin/sh", "-c", "exit 42"). WithStdinData("abcd1234"). Exec() framework.ExpectNoError(err) }) ginkgo.It("should support inline execution and attach", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) - ginkgo.By("executing a command with run and attach with stdin") // We wait for a non-empty line so we know kubectl has attached - runOutput := framework.NewKubectlCommand(ns, nsFlag, "run", "run-test", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--stdin", "--", "sh", "-c", "while [ -z \"$s\" ]; do read s; sleep 1; done; echo read:$s && cat && echo 'stdin closed'"). + runOutput := framework.NewKubectlCommand(ns, "run", "run-test", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--stdin", "--", "sh", "-c", "while [ -z \"$s\" ]; do read s; sleep 1; done; echo read:$s && cat && echo 'stdin closed'"). WithStdinData("value\nabcd1234"). ExecOrDie(ns) gomega.Expect(runOutput).To(gomega.ContainSubstring("read:value")) @@ -579,7 +575,7 @@ var _ = SIGDescribe("Kubectl client", func() { // "stdin closed", but hasn't exited yet. // We wait 10 seconds before printing to give time to kubectl to attach // to the container, this does not solve the race though. - runOutput = framework.NewKubectlCommand(ns, fmt.Sprintf("--namespace=%v", ns), "run", "run-test-2", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--", "sh", "-c", "sleep 10; cat && echo 'stdin closed'"). + runOutput = framework.NewKubectlCommand(ns, "run", "run-test-2", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--", "sh", "-c", "sleep 10; cat && echo 'stdin closed'"). WithStdinData("abcd1234"). ExecOrDie(ns) gomega.Expect(runOutput).ToNot(gomega.ContainSubstring("abcd1234")) @@ -588,7 +584,7 @@ var _ = SIGDescribe("Kubectl client", func() { gomega.Expect(c.CoreV1().Pods(ns).Delete(context.TODO(), "run-test-2", metav1.DeleteOptions{})).To(gomega.BeNil()) ginkgo.By("executing a command with run and attach with stdin with open stdin should remain running") - runOutput = framework.NewKubectlCommand(ns, nsFlag, "run", "run-test-3", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--stdin", "--", "sh", "-c", "cat && echo 'stdin closed'"). + runOutput = framework.NewKubectlCommand(ns, "run", "run-test-3", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--stdin", "--", "sh", "-c", "cat && echo 'stdin closed'"). WithStdinData("abcd1234\n"). ExecOrDie(ns) gomega.Expect(runOutput).ToNot(gomega.ContainSubstring("stdin closed")) @@ -605,7 +601,7 @@ var _ = SIGDescribe("Kubectl client", func() { if !e2epod.CheckPodsRunningReady(c, ns, []string{runTestPod.Name}, 1*time.Second) { framework.Failf("Pod %q of Job %q should still be running", runTestPod.Name, "run-test-3") } - logOutput := framework.RunKubectlOrDie(ns, nsFlag, "logs", runTestPod.Name) + logOutput := framework.RunKubectlOrDie(ns, "logs", runTestPod.Name) gomega.Expect(logOutput).ToNot(gomega.ContainSubstring("stdin closed")) return strings.Contains(logOutput, "abcd1234"), nil }) @@ -615,17 +611,16 @@ var _ = SIGDescribe("Kubectl client", func() { }) ginkgo.It("should contain last line of the log", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) podName := "run-log-test" ginkgo.By("executing a command with run") - framework.RunKubectlOrDie(ns, "run", podName, "--image="+busyboxImage, "--restart=OnFailure", nsFlag, "--", "sh", "-c", "sleep 10; seq 100 | while read i; do echo $i; sleep 0.01; done; echo EOF") + framework.RunKubectlOrDie(ns, "run", podName, "--image="+busyboxImage, "--restart=OnFailure", "--", "sh", "-c", "sleep 10; seq 100 | while read i; do echo $i; sleep 0.01; done; echo EOF") if !e2epod.CheckPodsRunningReadyOrSucceeded(c, ns, []string{podName}, framework.PodStartTimeout) { framework.Failf("Pod for run-log-test was not ready") } - logOutput := framework.RunKubectlOrDie(ns, nsFlag, "logs", "-f", "run-log-test") + logOutput := framework.RunKubectlOrDie(ns, "logs", "-f", "run-log-test") gomega.Expect(logOutput).To(gomega.ContainSubstring("EOF")) }) @@ -807,12 +802,11 @@ metadata: ginkgo.It("should apply a new configuration to an existing RC", func() { controllerJSON := commonutils.SubstituteImageName(string(readTestFileOrDie(agnhostControllerFilename))) - nsFlag := fmt.Sprintf("--namespace=%v", ns) ginkgo.By("creating Agnhost RC") - framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-") ginkgo.By("applying a modified configuration") stdin := modifyReplicationControllerConfiguration(controllerJSON) - framework.NewKubectlCommand(ns, "apply", "-f", "-", nsFlag). + framework.NewKubectlCommand(ns, "apply", "-f", "-"). WithStdinReader(stdin). ExecOrDie(ns) ginkgo.By("checking the result") @@ -820,19 +814,18 @@ metadata: }) ginkgo.It("should reuse port when apply to an existing SVC", func() { serviceJSON := readTestFileOrDie(agnhostServiceFilename) - nsFlag := fmt.Sprintf("--namespace=%v", ns) ginkgo.By("creating Agnhost SVC") - framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "create", "-f", "-") ginkgo.By("getting the original port") - originalNodePort := framework.RunKubectlOrDie(ns, "get", "service", "agnhost-primary", nsFlag, "-o", "jsonpath={.spec.ports[0].port}") + originalNodePort := framework.RunKubectlOrDie(ns, "get", "service", "agnhost-primary", "-o", "jsonpath={.spec.ports[0].port}") ginkgo.By("applying the same configuration") - framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "apply", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "apply", "-f", "-") ginkgo.By("getting the port after applying configuration") - currentNodePort := framework.RunKubectlOrDie(ns, "get", "service", "agnhost-primary", nsFlag, "-o", "jsonpath={.spec.ports[0].port}") + currentNodePort := framework.RunKubectlOrDie(ns, "get", "service", "agnhost-primary", "-o", "jsonpath={.spec.ports[0].port}") ginkgo.By("checking the result") if originalNodePort != currentNodePort { @@ -844,23 +837,22 @@ metadata: deployment1Yaml := commonutils.SubstituteImageName(string(readTestFileOrDie(httpdDeployment1Filename))) deployment2Yaml := commonutils.SubstituteImageName(string(readTestFileOrDie(httpdDeployment2Filename))) deployment3Yaml := commonutils.SubstituteImageName(string(readTestFileOrDie(httpdDeployment3Filename))) - nsFlag := fmt.Sprintf("--namespace=%v", ns) ginkgo.By("deployment replicas number is 2") - framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "-f", "-") ginkgo.By("check the last-applied matches expectations annotations") - output := framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "view-last-applied", "-f", "-", nsFlag, "-o", "json") + output := framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "view-last-applied", "-f", "-", "-o", "json") requiredString := "\"replicas\": 2" if !strings.Contains(output, requiredString) { framework.Failf("Missing %s in kubectl view-last-applied", requiredString) } ginkgo.By("apply file doesn't have replicas") - framework.RunKubectlOrDieInput(ns, deployment2Yaml, "apply", "set-last-applied", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, deployment2Yaml, "apply", "set-last-applied", "-f", "-") ginkgo.By("check last-applied has been updated, annotations doesn't have replicas") - output = framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "view-last-applied", "-f", "-", nsFlag, "-o", "json") + output = framework.RunKubectlOrDieInput(ns, deployment1Yaml, "apply", "view-last-applied", "-f", "-", "-o", "json") requiredString = "\"replicas\": 2" if strings.Contains(output, requiredString) { framework.Failf("Presenting %s in kubectl view-last-applied", requiredString) @@ -869,13 +861,13 @@ metadata: ginkgo.By("scale set replicas to 3") httpdDeploy := "httpd-deployment" debugDiscovery() - framework.RunKubectlOrDie(ns, "scale", "deployment", httpdDeploy, "--replicas=3", nsFlag) + framework.RunKubectlOrDie(ns, "scale", "deployment", httpdDeploy, "--replicas=3") ginkgo.By("apply file doesn't have replicas but image changed") - framework.RunKubectlOrDieInput(ns, deployment3Yaml, "apply", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, deployment3Yaml, "apply", "-f", "-") ginkgo.By("verify replicas still is 3 and image has been updated") - output = framework.RunKubectlOrDieInput(ns, deployment3Yaml, "get", "-f", "-", nsFlag, "-o", "json") + output = framework.RunKubectlOrDieInput(ns, deployment3Yaml, "get", "-f", "-", "-o", "json") requiredItems := []string{"\"replicas\": 3", imageutils.GetE2EImage(imageutils.Httpd)} for _, item := range requiredItems { if !strings.Contains(output, item) { @@ -925,16 +917,15 @@ metadata: framework.ConformanceIt("should check if kubectl can dry-run update Pods", func() { ginkgo.By("running the image " + httpdImage) podName := "e2e-test-httpd-pod" - nsFlag := fmt.Sprintf("--namespace=%v", ns) - framework.RunKubectlOrDie(ns, "run", podName, "--image="+httpdImage, "--labels=run="+podName, nsFlag) + framework.RunKubectlOrDie(ns, "run", podName, "--image="+httpdImage, "--labels=run="+podName) ginkgo.By("replace the image in the pod with server-side dry-run") - podJSON := framework.RunKubectlOrDie(ns, "get", "pod", podName, "-o", "json", nsFlag) + podJSON := framework.RunKubectlOrDie(ns, "get", "pod", podName, "-o", "json") podJSON = strings.Replace(podJSON, httpdImage, busyboxImage, 1) if !strings.Contains(podJSON, busyboxImage) { framework.Failf("Failed replacing image from %s to %s in:\n%s\n", httpdImage, busyboxImage, podJSON) } - framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", "--dry-run", "server", nsFlag) + framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", "--dry-run", "server") ginkgo.By("verifying the pod " + podName + " has the right image " + httpdImage) pod, err := c.CoreV1().Pods(ns).Get(context.TODO(), podName, metav1.GetOptions{}) @@ -946,7 +937,7 @@ metadata: framework.Failf("Failed creating pod with expected image %s", httpdImage) } - framework.RunKubectlOrDie(ns, "delete", "pods", podName, nsFlag) + framework.RunKubectlOrDie(ns, "delete", "pods", podName) }) }) @@ -1112,16 +1103,15 @@ metadata: controllerJSON := commonutils.SubstituteImageName(string(readTestFileOrDie(agnhostControllerFilename))) serviceJSON := readTestFileOrDie(agnhostServiceFilename) - nsFlag := fmt.Sprintf("--namespace=%v", ns) - framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-", nsFlag) - framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-") + framework.RunKubectlOrDieInput(ns, string(serviceJSON[:]), "create", "-f", "-") ginkgo.By("Waiting for Agnhost primary to start.") waitForOrFailWithDebug(1) // Pod forEachPod(func(pod v1.Pod) { - output := framework.RunKubectlOrDie(ns, "describe", "pod", pod.Name, nsFlag) + output := framework.RunKubectlOrDie(ns, "describe", "pod", pod.Name) requiredStrings := [][]string{ {"Name:", "agnhost-primary-"}, {"Namespace:", ns}, @@ -1152,10 +1142,10 @@ metadata: {"Pod Template:"}, {"Image:", agnhostImage}, {"Events:"}} - checkKubectlOutputWithRetry(ns, requiredStrings, "describe", "rc", "agnhost-primary", nsFlag) + checkKubectlOutputWithRetry(ns, requiredStrings, "describe", "rc", "agnhost-primary") // Service - output := framework.RunKubectlOrDie(ns, "describe", "service", "agnhost-primary", nsFlag) + output := framework.RunKubectlOrDie(ns, "describe", "service", "agnhost-primary") requiredStrings = [][]string{ {"Name:", "agnhost-primary"}, {"Namespace:", ns}, @@ -1208,9 +1198,8 @@ metadata: ginkgo.It("should check if kubectl describe prints relevant information for cronjob", func() { ginkgo.By("creating a cronjob") - nsFlag := fmt.Sprintf("--namespace=%v", ns) cronjobYaml := commonutils.SubstituteImageName(string(readTestFileOrDie("busybox-cronjob.yaml"))) - framework.RunKubectlOrDieInput(ns, cronjobYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, cronjobYaml, "create", "-f", "-") ginkgo.By("waiting for cronjob to start.") err := wait.PollImmediate(time.Second, time.Minute, func() (bool, error) { @@ -1223,7 +1212,7 @@ metadata: framework.ExpectNoError(err) ginkgo.By("verifying kubectl describe prints") - output := framework.RunKubectlOrDie(ns, "describe", "cronjob", "cronjob-test", nsFlag) + output := framework.RunKubectlOrDie(ns, "describe", "cronjob", "cronjob-test") requiredStrings := [][]string{ {"Name:", "cronjob-test"}, {"Namespace:", ns}, @@ -1251,14 +1240,13 @@ metadata: */ framework.ConformanceIt("should create services for rc ", func() { controllerJSON := commonutils.SubstituteImageName(string(readTestFileOrDie(agnhostControllerFilename))) - nsFlag := fmt.Sprintf("--namespace=%v", ns) agnhostPort := 6379 ginkgo.By("creating Agnhost RC") framework.Logf("namespace %v", ns) - framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-") // It may take a while for the pods to get registered in some cases, wait to be sure. ginkgo.By("Waiting for Agnhost primary to start.") @@ -1316,12 +1304,12 @@ metadata: } ginkgo.By("exposing RC") - framework.RunKubectlOrDie(ns, "expose", "rc", "agnhost-primary", "--name=rm2", "--port=1234", fmt.Sprintf("--target-port=%d", agnhostPort), nsFlag) + framework.RunKubectlOrDie(ns, "expose", "rc", "agnhost-primary", "--name=rm2", "--port=1234", fmt.Sprintf("--target-port=%d", agnhostPort)) e2enetwork.WaitForService(c, ns, "rm2", true, framework.Poll, framework.ServiceStartTimeout) validateService("rm2", 1234, framework.ServiceStartTimeout) ginkgo.By("exposing service") - framework.RunKubectlOrDie(ns, "expose", "service", "rm2", "--name=rm3", "--port=2345", fmt.Sprintf("--target-port=%d", agnhostPort), nsFlag) + framework.RunKubectlOrDie(ns, "expose", "service", "rm2", "--name=rm3", "--port=2345", fmt.Sprintf("--target-port=%d", agnhostPort)) e2enetwork.WaitForService(c, ns, "rm3", true, framework.Poll, framework.ServiceStartTimeout) validateService("rm3", 2345, framework.ServiceStartTimeout) }) @@ -1329,12 +1317,10 @@ metadata: ginkgo.Describe("Kubectl label", func() { var podYaml string - var nsFlag string ginkgo.BeforeEach(func() { ginkgo.By("creating the pod") podYaml = commonutils.SubstituteImageName(string(readTestFileOrDie("pause-pod.yaml.in"))) - nsFlag = fmt.Sprintf("--namespace=%v", ns) - framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-") framework.ExpectEqual(e2epod.CheckPodsRunningReady(c, ns, []string{pausePodName}, framework.PodStartTimeout), true) }) ginkgo.AfterEach(func() { @@ -1351,17 +1337,17 @@ metadata: labelValue := "testing-label-value" ginkgo.By("adding the label " + labelName + " with value " + labelValue + " to a pod") - framework.RunKubectlOrDie(ns, "label", "pods", pausePodName, labelName+"="+labelValue, nsFlag) + framework.RunKubectlOrDie(ns, "label", "pods", pausePodName, labelName+"="+labelValue) ginkgo.By("verifying the pod has the label " + labelName + " with the value " + labelValue) - output := framework.RunKubectlOrDie(ns, "get", "pod", pausePodName, "-L", labelName, nsFlag) + output := framework.RunKubectlOrDie(ns, "get", "pod", pausePodName, "-L", labelName) if !strings.Contains(output, labelValue) { framework.Failf("Failed updating label " + labelName + " to the pod " + pausePodName) } ginkgo.By("removing the label " + labelName + " of a pod") - framework.RunKubectlOrDie(ns, "label", "pods", pausePodName, labelName+"-", nsFlag) + framework.RunKubectlOrDie(ns, "label", "pods", pausePodName, labelName+"-") ginkgo.By("verifying the pod doesn't have the label " + labelName) - output = framework.RunKubectlOrDie(ns, "get", "pod", pausePodName, "-L", labelName, nsFlag) + output = framework.RunKubectlOrDie(ns, "get", "pod", pausePodName, "-L", labelName) if strings.Contains(output, labelValue) { framework.Failf("Failed removing label " + labelName + " of the pod " + pausePodName) } @@ -1370,12 +1356,10 @@ metadata: ginkgo.Describe("Kubectl copy", func() { var podYaml string - var nsFlag string ginkgo.BeforeEach(func() { ginkgo.By("creating the pod") - nsFlag = fmt.Sprintf("--namespace=%v", ns) podYaml = commonutils.SubstituteImageName(string(readTestFileOrDie("busybox-pod.yaml"))) - framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, podYaml, "create", "-f", "-") framework.ExpectEqual(e2epod.CheckPodsRunningReady(c, ns, []string{busyboxPodName}, framework.PodStartTimeout), true) }) ginkgo.AfterEach(func() { @@ -1396,7 +1380,7 @@ metadata: } ginkgo.By("specifying a remote filepath " + podSource + " on the pod") - framework.RunKubectlOrDie(ns, "cp", podSource, tempDestination.Name(), nsFlag) + framework.RunKubectlOrDie(ns, "cp", podSource, tempDestination.Name()) ginkgo.By("verifying that the contents of the remote file " + podSource + " have been copied to a local file " + tempDestination.Name()) localData, err := ioutil.ReadAll(tempDestination) if err != nil { @@ -1409,17 +1393,15 @@ metadata: }) ginkgo.Describe("Kubectl logs", func() { - var nsFlag string podName := "logs-generator" containerName := "logs-generator" ginkgo.BeforeEach(func() { ginkgo.By("creating an pod") - nsFlag = fmt.Sprintf("--namespace=%v", ns) // Agnhost image generates logs for a total of 100 lines over 20s. - framework.RunKubectlOrDie(ns, "run", podName, "--image="+agnhostImage, nsFlag, "--restart=Never", "--", "logs-generator", "--log-lines-total", "100", "--run-duration", "20s") + framework.RunKubectlOrDie(ns, "run", podName, "--image="+agnhostImage, "--restart=Never", "--", "logs-generator", "--log-lines-total", "100", "--run-duration", "20s") }) ginkgo.AfterEach(func() { - framework.RunKubectlOrDie(ns, "delete", "pod", podName, nsFlag) + framework.RunKubectlOrDie(ns, "delete", "pod", podName) }) /* @@ -1450,19 +1432,19 @@ metadata: framework.ExpectNoError(err) ginkgo.By("limiting log lines") - out := framework.RunKubectlOrDie(ns, "logs", podName, containerName, nsFlag, "--tail=1") + out := framework.RunKubectlOrDie(ns, "logs", podName, containerName, "--tail=1") framework.Logf("got output %q", out) gomega.Expect(len(out)).NotTo(gomega.BeZero()) framework.ExpectEqual(len(lines(out)), 1) ginkgo.By("limiting log bytes") - out = framework.RunKubectlOrDie(ns, "logs", podName, containerName, nsFlag, "--limit-bytes=1") + out = framework.RunKubectlOrDie(ns, "logs", podName, containerName, "--limit-bytes=1") framework.Logf("got output %q", out) framework.ExpectEqual(len(lines(out)), 1) framework.ExpectEqual(len(out), 1) ginkgo.By("exposing timestamps") - out = framework.RunKubectlOrDie(ns, "logs", podName, containerName, nsFlag, "--tail=1", "--timestamps") + out = framework.RunKubectlOrDie(ns, "logs", podName, containerName, "--tail=1", "--timestamps") framework.Logf("got output %q", out) l := lines(out) framework.ExpectEqual(len(l), 1) @@ -1479,9 +1461,9 @@ metadata: // because the granularity is only 1 second and // it could end up rounding the wrong way. time.Sleep(2500 * time.Millisecond) // ensure that startup logs on the node are seen as older than 1s - recentOut := framework.RunKubectlOrDie(ns, "logs", podName, containerName, nsFlag, "--since=1s") + recentOut := framework.RunKubectlOrDie(ns, "logs", podName, containerName, "--since=1s") recent := len(strings.Split(recentOut, "\n")) - olderOut := framework.RunKubectlOrDie(ns, "logs", podName, containerName, nsFlag, "--since=24h") + olderOut := framework.RunKubectlOrDie(ns, "logs", podName, containerName, "--since=24h") older := len(strings.Split(olderOut, "\n")) gomega.Expect(recent).To(gomega.BeNumerically("<", older), "expected recent(%v) to be less than older(%v)\nrecent lines:\n%v\nolder lines:\n%v\n", recent, older, recentOut, olderOut) }) @@ -1495,14 +1477,13 @@ metadata: */ framework.ConformanceIt("should add annotations for pods in rc ", func() { controllerJSON := commonutils.SubstituteImageName(string(readTestFileOrDie(agnhostControllerFilename))) - nsFlag := fmt.Sprintf("--namespace=%v", ns) ginkgo.By("creating Agnhost RC") - framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, controllerJSON, "create", "-f", "-") ginkgo.By("Waiting for Agnhost primary to start.") waitForOrFailWithDebug(1) ginkgo.By("patching all pods") forEachPod(func(pod v1.Pod) { - framework.RunKubectlOrDie(ns, "patch", "pod", pod.Name, nsFlag, "-p", "{\"metadata\":{\"annotations\":{\"x\":\"y\"}}}") + framework.RunKubectlOrDie(ns, "patch", "pod", pod.Name, "-p", "{\"metadata\":{\"annotations\":{\"x\":\"y\"}}}") }) ginkgo.By("checking annotations") @@ -1539,16 +1520,14 @@ metadata: }) ginkgo.Describe("Kubectl run pod", func() { - var nsFlag string var podName string ginkgo.BeforeEach(func() { - nsFlag = fmt.Sprintf("--namespace=%v", ns) podName = "e2e-test-httpd-pod" }) ginkgo.AfterEach(func() { - framework.RunKubectlOrDie(ns, "delete", "pods", podName, nsFlag) + framework.RunKubectlOrDie(ns, "delete", "pods", podName) }) /* @@ -1558,7 +1537,7 @@ metadata: */ framework.ConformanceIt("should create a pod from an image when restart is Never ", func() { ginkgo.By("running the image " + httpdImage) - framework.RunKubectlOrDie(ns, "run", podName, "--restart=Never", "--image="+httpdImage, nsFlag) + framework.RunKubectlOrDie(ns, "run", podName, "--restart=Never", "--image="+httpdImage) ginkgo.By("verifying the pod " + podName + " was created") pod, err := c.CoreV1().Pods(ns).Get(context.TODO(), podName, metav1.GetOptions{}) if err != nil { @@ -1575,16 +1554,14 @@ metadata: }) ginkgo.Describe("Kubectl replace", func() { - var nsFlag string var podName string ginkgo.BeforeEach(func() { - nsFlag = fmt.Sprintf("--namespace=%v", ns) podName = "e2e-test-httpd-pod" }) ginkgo.AfterEach(func() { - framework.RunKubectlOrDie(ns, "delete", "pods", podName, nsFlag) + framework.RunKubectlOrDie(ns, "delete", "pods", podName) }) /* @@ -1594,7 +1571,7 @@ metadata: */ framework.ConformanceIt("should update a single-container pod's image ", func() { ginkgo.By("running the image " + httpdImage) - framework.RunKubectlOrDie(ns, "run", podName, "--image="+httpdImage, "--labels=run="+podName, nsFlag) + framework.RunKubectlOrDie(ns, "run", podName, "--image="+httpdImage, "--labels=run="+podName) ginkgo.By("verifying the pod " + podName + " is running") label := labels.SelectorFromSet(labels.Set(map[string]string{"run": podName})) @@ -1604,14 +1581,14 @@ metadata: } ginkgo.By("verifying the pod " + podName + " was created") - podJSON := framework.RunKubectlOrDie(ns, "get", "pod", podName, nsFlag, "-o", "json") + podJSON := framework.RunKubectlOrDie(ns, "get", "pod", podName, "-o", "json") if !strings.Contains(podJSON, podName) { framework.Failf("Failed to find pod %s in [%s]", podName, podJSON) } ginkgo.By("replace the image in the pod") podJSON = strings.Replace(podJSON, httpdImage, busyboxImage, 1) - framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", nsFlag) + framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-") ginkgo.By("verifying the pod " + podName + " has the right image " + busyboxImage) pod, err := c.CoreV1().Pods(ns).Get(context.TODO(), podName, metav1.GetOptions{}) @@ -1791,11 +1768,10 @@ metadata: ginkgo.Describe("Kubectl create quota", func() { ginkgo.It("should create a quota without scopes", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) quotaName := "million" ginkgo.By("calling kubectl quota") - framework.RunKubectlOrDie(ns, "create", "quota", quotaName, "--hard=pods=1000000,services=1000000", nsFlag) + framework.RunKubectlOrDie(ns, "create", "quota", quotaName, "--hard=pods=1000000,services=1000000") ginkgo.By("verifying that the quota was created") quota, err := c.CoreV1().ResourceQuotas(ns).Get(context.TODO(), quotaName, metav1.GetOptions{}) @@ -1820,11 +1796,10 @@ metadata: }) ginkgo.It("should create a quota with scopes", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) quotaName := "scopes" ginkgo.By("calling kubectl quota") - framework.RunKubectlOrDie(ns, "create", "quota", quotaName, "--hard=pods=1000000", "--scopes=BestEffort,NotTerminating", nsFlag) + framework.RunKubectlOrDie(ns, "create", "quota", quotaName, "--hard=pods=1000000", "--scopes=BestEffort,NotTerminating") ginkgo.By("verifying that the quota was created") quota, err := c.CoreV1().ResourceQuotas(ns).Get(context.TODO(), quotaName, metav1.GetOptions{}) @@ -1848,11 +1823,10 @@ metadata: }) ginkgo.It("should reject quota with invalid scopes", func() { - nsFlag := fmt.Sprintf("--namespace=%v", ns) quotaName := "scopes" ginkgo.By("calling kubectl quota") - out, err := framework.RunKubectl(ns, "create", "quota", quotaName, "--hard=hard=pods=1000000", "--scopes=Foo", nsFlag) + out, err := framework.RunKubectl(ns, "create", "quota", quotaName, "--hard=hard=pods=1000000", "--scopes=Foo") if err == nil { framework.Failf("Expected kubectl to fail, but it succeeded: %s", out) } @@ -2158,19 +2132,18 @@ func startLocalProxy() (srv *httptest.Server, logs *bytes.Buffer) { // createApplyCustomResource asserts that given CustomResource be created and applied // without being rejected by client-side validation func createApplyCustomResource(resource, namespace, name string, crd *crd.TestCrd) error { - ns := fmt.Sprintf("--namespace=%v", namespace) ginkgo.By("successfully create CR") - if _, err := framework.RunKubectlInput(namespace, resource, ns, "create", "--validate=true", "-f", "-"); err != nil { - return fmt.Errorf("failed to create CR %s in namespace %s: %v", resource, ns, err) + if _, err := framework.RunKubectlInput(namespace, resource, "create", "--validate=true", "-f", "-"); err != nil { + return fmt.Errorf("failed to create CR %s in namespace %s: %v", resource, namespace, err) } - if _, err := framework.RunKubectl(namespace, ns, "delete", crd.Crd.Spec.Names.Plural, name); err != nil { + if _, err := framework.RunKubectl(namespace, "delete", crd.Crd.Spec.Names.Plural, name); err != nil { return fmt.Errorf("failed to delete CR %s: %v", name, err) } ginkgo.By("successfully apply CR") - if _, err := framework.RunKubectlInput(namespace, resource, ns, "apply", "--validate=true", "-f", "-"); err != nil { - return fmt.Errorf("failed to apply CR %s in namespace %s: %v", resource, ns, err) + if _, err := framework.RunKubectlInput(namespace, resource, "apply", "--validate=true", "-f", "-"); err != nil { + return fmt.Errorf("failed to apply CR %s in namespace %s: %v", resource, namespace, err) } - if _, err := framework.RunKubectl(namespace, ns, "delete", crd.Crd.Spec.Names.Plural, name); err != nil { + if _, err := framework.RunKubectl(namespace, "delete", crd.Crd.Spec.Names.Plural, name); err != nil { return fmt.Errorf("failed to delete CR %s: %v", name, err) } return nil @@ -2205,7 +2178,7 @@ func validateController(c clientset.Interface, containerImage string, replicas i ginkgo.By(fmt.Sprintf("waiting for all containers in %s pods to come up.", testname)) //testname should be selector waitLoop: for start := time.Now(); time.Since(start) < framework.PodStartTimeout; time.Sleep(5 * time.Second) { - getPodsOutput := framework.RunKubectlOrDie(ns, "get", "pods", "-o", "template", getPodsTemplate, "-l", testname, fmt.Sprintf("--namespace=%v", ns)) + getPodsOutput := framework.RunKubectlOrDie(ns, "get", "pods", "-o", "template", getPodsTemplate, "-l", testname) pods := strings.Fields(getPodsOutput) if numPods := len(pods); numPods != replicas { ginkgo.By(fmt.Sprintf("Replicas for %s: expected=%d actual=%d", testname, replicas, numPods)) @@ -2213,13 +2186,13 @@ waitLoop: } var runningPods []string for _, podID := range pods { - running := framework.RunKubectlOrDie(ns, "get", "pods", podID, "-o", "template", getContainerStateTemplate, fmt.Sprintf("--namespace=%v", ns)) + running := framework.RunKubectlOrDie(ns, "get", "pods", podID, "-o", "template", getContainerStateTemplate) if running != "true" { framework.Logf("%s is created but not running", podID) continue waitLoop } - currentImage := framework.RunKubectlOrDie(ns, "get", "pods", podID, "-o", "template", getImageTemplate, fmt.Sprintf("--namespace=%v", ns)) + currentImage := framework.RunKubectlOrDie(ns, "get", "pods", podID, "-o", "template", getImageTemplate) currentImage = trimDockerRegistry(currentImage) if currentImage != containerImage { framework.Logf("%s is created but running wrong image; expected: %s, actual: %s", podID, containerImage, currentImage) diff --git a/test/e2e/storage/testsuites/subpath.go b/test/e2e/storage/testsuites/subpath.go index 3781a5bdbfa78..4f493bc0ad08d 100644 --- a/test/e2e/storage/testsuites/subpath.go +++ b/test/e2e/storage/testsuites/subpath.go @@ -1071,5 +1071,5 @@ func podContainerExec(pod *v1.Pod, containerIndex int, command string) (string, shell = "/bin/sh" option = "-c" } - return framework.RunKubectl(pod.Namespace, "exec", fmt.Sprintf("--namespace=%s", pod.Namespace), pod.Name, "--container", pod.Spec.Containers[containerIndex].Name, "--", shell, option, command) + return framework.RunKubectl(pod.Namespace, "exec", pod.Name, "--container", pod.Spec.Containers[containerIndex].Name, "--", shell, option, command) } diff --git a/test/e2e/storage/vsphere/vsphere_utils.go b/test/e2e/storage/vsphere/vsphere_utils.go index c80c464efa122..b1623eabfa497 100644 --- a/test/e2e/storage/vsphere/vsphere_utils.go +++ b/test/e2e/storage/vsphere/vsphere_utils.go @@ -358,7 +358,7 @@ func getVSpherePodSpecWithVolumePaths(volumePaths []string, keyValuelabel map[st func verifyFilesExistOnVSphereVolume(namespace string, podName string, filePaths ...string) { for _, filePath := range filePaths { - _, err := framework.RunKubectl(namespace, "exec", fmt.Sprintf("--namespace=%s", namespace), podName, "--", "/bin/ls", filePath) + _, err := framework.RunKubectl(namespace, "exec", podName, "--", "/bin/ls", filePath) framework.ExpectNoError(err, fmt.Sprintf("failed to verify file: %q on the pod: %q", filePath, podName)) } } @@ -815,7 +815,7 @@ func expectFilesToBeAccessible(namespace string, pods []*v1.Pod, filePaths []str // writeContentToPodFile writes the given content to the specified file. func writeContentToPodFile(namespace, podName, filePath, content string) error { - _, err := framework.RunKubectl(namespace, "exec", fmt.Sprintf("--namespace=%s", namespace), podName, + _, err := framework.RunKubectl(namespace, "exec", podName, "--", "/bin/sh", "-c", fmt.Sprintf("echo '%s' > %s", content, filePath)) return err } @@ -823,7 +823,7 @@ func writeContentToPodFile(namespace, podName, filePath, content string) error { // expectFileContentToMatch checks if a given file contains the specified // content, else fails. func expectFileContentToMatch(namespace, podName, filePath, content string) { - _, err := framework.RunKubectl(namespace, "exec", fmt.Sprintf("--namespace=%s", namespace), podName, + _, err := framework.RunKubectl(namespace, "exec", podName, "--", "/bin/sh", "-c", fmt.Sprintf("grep '%s' %s", content, filePath)) framework.ExpectNoError(err, fmt.Sprintf("failed to match content of file: %q on the pod: %q", filePath, podName)) } diff --git a/test/e2e/upgrades/cassandra.go b/test/e2e/upgrades/cassandra.go index 2acb054e5b3c1..4fbf97f64df7d 100644 --- a/test/e2e/upgrades/cassandra.go +++ b/test/e2e/upgrades/cassandra.go @@ -65,7 +65,7 @@ func cassandraKubectlCreate(ns, file string) { framework.Fail(err.Error()) } input := string(data) - framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-", fmt.Sprintf("--namespace=%s", ns)) + framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-") } // Setup creates a Cassandra StatefulSet and a PDB. It also brings up a tester diff --git a/test/e2e/upgrades/etcd.go b/test/e2e/upgrades/etcd.go index 32ca170fd5970..243cd7cfb33b3 100644 --- a/test/e2e/upgrades/etcd.go +++ b/test/e2e/upgrades/etcd.go @@ -64,7 +64,7 @@ func kubectlCreate(ns, file string) { framework.Fail(err.Error()) } input := string(data) - framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-", fmt.Sprintf("--namespace=%s", ns)) + framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-") } // Setup creates etcd statefulset and then verifies that the etcd is writable. diff --git a/test/e2e/upgrades/mysql.go b/test/e2e/upgrades/mysql.go index 89f735b55efd8..edc94a5c20238 100644 --- a/test/e2e/upgrades/mysql.go +++ b/test/e2e/upgrades/mysql.go @@ -66,7 +66,7 @@ func mysqlKubectlCreate(ns, file string) { framework.Fail(err.Error()) } input := string(data) - framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-", fmt.Sprintf("--namespace=%s", ns)) + framework.RunKubectlOrDieInput(ns, input, "create", "-f", "-") } func (t *MySQLUpgradeTest) getServiceIP(f *framework.Framework, ns, svcName string) string { From beb5a3f48ae144b286d745aa47e102f2a3d37d8f Mon Sep 17 00:00:00 2001 From: zhouya0 Date: Tue, 15 Sep 2020 10:43:51 +0800 Subject: [PATCH 012/301] Clean up remaining ns flag --- test/e2e/kubectl/kubectl.go | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/test/e2e/kubectl/kubectl.go b/test/e2e/kubectl/kubectl.go index 1127900a47bed..a4a6bbcd0198f 100644 --- a/test/e2e/kubectl/kubectl.go +++ b/test/e2e/kubectl/kubectl.go @@ -170,33 +170,24 @@ properties: // Aware of the kubectl example files map. func cleanupKubectlInputs(fileContents string, ns string, selectors ...string) { ginkgo.By("using delete to clean up resources") - var nsArg string - if ns != "" { - nsArg = fmt.Sprintf("--namespace=%s", ns) - } // support backward compatibility : file paths or raw json - since we are removing file path // dependencies from this test. - framework.RunKubectlOrDieInput(ns, fileContents, "delete", "--grace-period=0", "--force", "-f", "-", nsArg) + framework.RunKubectlOrDieInput(ns, fileContents, "delete", "--grace-period=0", "--force", "-f", "-") assertCleanup(ns, selectors...) } // assertCleanup asserts that cleanup of a namespace wrt selectors occurred. func assertCleanup(ns string, selectors ...string) { - var nsArg string - if ns != "" { - nsArg = fmt.Sprintf("--namespace=%s", ns) - } - var e error verifyCleanupFunc := func() (bool, error) { e = nil for _, selector := range selectors { - resources := framework.RunKubectlOrDie(ns, "get", "rc,svc", "-l", selector, "--no-headers", nsArg) + resources := framework.RunKubectlOrDie(ns, "get", "rc,svc", "-l", selector, "--no-headers") if resources != "" { e = fmt.Errorf("Resources left running after stop:\n%s", resources) return false, nil } - pods := framework.RunKubectlOrDie(ns, "get", "pods", "-l", selector, nsArg, "-o", "go-template={{ range .items }}{{ if not .metadata.deletionTimestamp }}{{ .metadata.name }}{{ \"\\n\" }}{{ end }}{{ end }}") + pods := framework.RunKubectlOrDie(ns, "get", "pods", "-l", selector, "-o", "go-template={{ range .items }}{{ if not .metadata.deletionTimestamp }}{{ .metadata.name }}{{ \"\\n\" }}{{ end }}{{ end }}") if pods != "" { e = fmt.Errorf("Pods left unterminated after stop:\n%s", pods) return false, nil From 0046185bf8432e1be5b96ebf1092f1de0a09563a Mon Sep 17 00:00:00 2001 From: Maciej Szulik Date: Thu, 15 Oct 2020 12:51:58 +0200 Subject: [PATCH 013/301] Fix --dry-run invocation in kubectl e2e --- test/e2e/kubectl/kubectl.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/e2e/kubectl/kubectl.go b/test/e2e/kubectl/kubectl.go index a4a6bbcd0198f..d8dc465bd691d 100644 --- a/test/e2e/kubectl/kubectl.go +++ b/test/e2e/kubectl/kubectl.go @@ -916,7 +916,7 @@ metadata: if !strings.Contains(podJSON, busyboxImage) { framework.Failf("Failed replacing image from %s to %s in:\n%s\n", httpdImage, busyboxImage, podJSON) } - framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", "--dry-run", "server") + framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", "--dry-run=server") ginkgo.By("verifying the pod " + podName + " has the right image " + httpdImage) pod, err := c.CoreV1().Pods(ns).Get(context.TODO(), podName, metav1.GetOptions{}) From 8f593ace25db5e42f1405867e9d225b495dc8520 Mon Sep 17 00:00:00 2001 From: Carlos Panato Date: Fri, 23 Oct 2020 15:10:54 +0200 Subject: [PATCH 014/301] use patch instead of replace to test the dry-run option --- test/conformance/testdata/conformance.yaml | 6 +++--- test/e2e/kubectl/kubectl.go | 10 +++------- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/test/conformance/testdata/conformance.yaml b/test/conformance/testdata/conformance.yaml index f2b1e25a16467..0c35b2a05e907 100755 --- a/test/conformance/testdata/conformance.yaml +++ b/test/conformance/testdata/conformance.yaml @@ -1474,9 +1474,9 @@ codename: '[sig-cli] Kubectl client Kubectl server-side dry-run should check if kubectl can dry-run update Pods [Conformance]' description: The command 'kubectl run' must create a pod with the specified image - name. After, the command 'kubectl replace --dry-run=server' should update the - Pod with the new image name and server-side dry-run enabled. The image name must - not change. + name. After, the command 'kubectl patch pod -p {...} --dry-run=server' should + update the Pod with the new image name and server-side dry-run enabled. The image + name must not change. release: v1.19 file: test/e2e/kubectl/kubectl.go - testname: Kubectl, version diff --git a/test/e2e/kubectl/kubectl.go b/test/e2e/kubectl/kubectl.go index d8dc465bd691d..ce52c2a175fe2 100644 --- a/test/e2e/kubectl/kubectl.go +++ b/test/e2e/kubectl/kubectl.go @@ -903,7 +903,7 @@ metadata: /* Release: v1.19 Testname: Kubectl, server-side dry-run Pod - Description: The command 'kubectl run' must create a pod with the specified image name. After, the command 'kubectl replace --dry-run=server' should update the Pod with the new image name and server-side dry-run enabled. The image name must not change. + Description: The command 'kubectl run' must create a pod with the specified image name. After, the command 'kubectl patch pod -p {...} --dry-run=server' should update the Pod with the new image name and server-side dry-run enabled. The image name must not change. */ framework.ConformanceIt("should check if kubectl can dry-run update Pods", func() { ginkgo.By("running the image " + httpdImage) @@ -911,12 +911,8 @@ metadata: framework.RunKubectlOrDie(ns, "run", podName, "--image="+httpdImage, "--labels=run="+podName) ginkgo.By("replace the image in the pod with server-side dry-run") - podJSON := framework.RunKubectlOrDie(ns, "get", "pod", podName, "-o", "json") - podJSON = strings.Replace(podJSON, httpdImage, busyboxImage, 1) - if !strings.Contains(podJSON, busyboxImage) { - framework.Failf("Failed replacing image from %s to %s in:\n%s\n", httpdImage, busyboxImage, podJSON) - } - framework.RunKubectlOrDieInput(ns, podJSON, "replace", "-f", "-", "--dry-run=server") + specImage := fmt.Sprintf(`{"spec":{"containers":[{"name": "%s","image": "%s"}]}}`, podName, busyboxImage) + framework.RunKubectlOrDie(ns, "patch", "pod", podName, "-p", specImage, "--dry-run=server") ginkgo.By("verifying the pod " + podName + " has the right image " + httpdImage) pod, err := c.CoreV1().Pods(ns).Get(context.TODO(), podName, metav1.GetOptions{}) From 9546a0e88d62afd8fdf50c4ed91514d5192db450 Mon Sep 17 00:00:00 2001 From: Anago GCB Date: Wed, 11 Nov 2020 13:08:21 +0000 Subject: [PATCH 015/301] Release commit for Kubernetes v1.19.5-rc.0 From 454965f0238c49f8135ea9f27895a0ebfaac52fb Mon Sep 17 00:00:00 2001 From: Anago GCB Date: Wed, 11 Nov 2020 14:02:51 +0000 Subject: [PATCH 016/301] Update CHANGELOG/CHANGELOG-1.19.md for v1.19.4 --- CHANGELOG/CHANGELOG-1.19.md | 288 ++++++++++++++++++++++++------------ 1 file changed, 193 insertions(+), 95 deletions(-) diff --git a/CHANGELOG/CHANGELOG-1.19.md b/CHANGELOG/CHANGELOG-1.19.md index c51920fa7cdb7..63832420d20b5 100644 --- a/CHANGELOG/CHANGELOG-1.19.md +++ b/CHANGELOG/CHANGELOG-1.19.md @@ -1,57 +1,70 @@ -- [v1.19.3](#v1193) - - [Downloads for v1.19.3](#downloads-for-v1193) +- [v1.19.4](#v1194) + - [Downloads for v1.19.4](#downloads-for-v1194) - [Source Code](#source-code) - [Client binaries](#client-binaries) - [Server binaries](#server-binaries) - [Node binaries](#node-binaries) - - [Changelog since v1.19.2](#changelog-since-v1192) + - [Changelog since v1.19.3](#changelog-since-v1193) - [Changes by Kind](#changes-by-kind) - - [Feature](#feature) - - [Design](#design) - [Bug or Regression](#bug-or-regression) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake) - [Dependencies](#dependencies) - [Added](#added) - [Changed](#changed) - [Removed](#removed) -- [v1.19.2](#v1192) - - [Downloads for v1.19.2](#downloads-for-v1192) +- [v1.19.3](#v1193) + - [Downloads for v1.19.3](#downloads-for-v1193) - [Source Code](#source-code-1) - [Client binaries](#client-binaries-1) - [Server binaries](#server-binaries-1) - [Node binaries](#node-binaries-1) - - [Changelog since v1.19.1](#changelog-since-v1191) + - [Changelog since v1.19.2](#changelog-since-v1192) - [Changes by Kind](#changes-by-kind-1) - - [API Change](#api-change) + - [Feature](#feature) + - [Design](#design) - [Bug or Regression](#bug-or-regression-1) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-1) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake) - [Dependencies](#dependencies-1) - [Added](#added-1) - [Changed](#changed-1) - [Removed](#removed-1) -- [v1.19.1](#v1191) - - [Downloads for v1.19.1](#downloads-for-v1191) +- [v1.19.2](#v1192) + - [Downloads for v1.19.2](#downloads-for-v1192) - [Source Code](#source-code-2) - [Client binaries](#client-binaries-2) - [Server binaries](#server-binaries-2) - [Node binaries](#node-binaries-2) - - [Changelog since v1.19.0](#changelog-since-v1190) + - [Changelog since v1.19.1](#changelog-since-v1191) - [Changes by Kind](#changes-by-kind-2) + - [API Change](#api-change) - [Bug or Regression](#bug-or-regression-2) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-2) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-1) - [Dependencies](#dependencies-2) - [Added](#added-2) - [Changed](#changed-2) - [Removed](#removed-2) +- [v1.19.1](#v1191) + - [Downloads for v1.19.1](#downloads-for-v1191) + - [Source Code](#source-code-3) + - [Client binaries](#client-binaries-3) + - [Server binaries](#server-binaries-3) + - [Node binaries](#node-binaries-3) + - [Changelog since v1.19.0](#changelog-since-v1190) + - [Changes by Kind](#changes-by-kind-3) + - [Bug or Regression](#bug-or-regression-3) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-2) + - [Dependencies](#dependencies-3) + - [Added](#added-3) + - [Changed](#changed-3) + - [Removed](#removed-3) - [v1.19.0](#v1190) - [Downloads for v1.19.0](#downloads-for-v1190) - - [Client Binaries](#client-binaries-3) - - [Server Binaries](#server-binaries-3) - - [Node Binaries](#node-binaries-3) + - [Client Binaries](#client-binaries-4) + - [Server Binaries](#server-binaries-4) + - [Node Binaries](#node-binaries-4) - [Changelog since v1.18.0](#changelog-since-v1180) - - [What’s New (Major Themes)](#what’s-new-major-themes) + - [What’s New (Major Themes)](#whats-new-major-themes) - [Deprecation warnings](#deprecation-warnings) - [Avoiding permanent beta](#avoiding-permanent-beta) - [Expanded CLI support for debugging workloads and nodes](#expanded-cli-support-for-debugging-workloads-and-nodes) @@ -71,181 +84,266 @@ - [Windows containerd support graduates to beta](#windows-containerd-support-graduates-to-beta) - [Increase the Kubernetes support window to one year](#increase-the-kubernetes-support-window-to-one-year) - [Known Issues](#known-issues) - - [Urgent Upgrade Notes ](#urgent-upgrade-notes-) + - [Urgent Upgrade Notes](#urgent-upgrade-notes) - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade) - - [Changes by Kind](#changes-by-kind-3) + - [Changes by Kind](#changes-by-kind-4) - [Deprecation](#deprecation) - [API Change](#api-change-1) - [Feature](#feature-1) - [Documentation](#documentation) - [Failing Test](#failing-test) - - [Bug or Regression](#bug-or-regression-3) + - [Bug or Regression](#bug-or-regression-4) - [Other (Cleanup or Flake)](#other-cleanup-or-flake-3) - - [Dependencies](#dependencies-3) - - [Added](#added-3) - - [Changed](#changed-3) - - [Removed](#removed-3) - [Dependencies](#dependencies-4) - [Added](#added-4) - [Changed](#changed-4) - [Removed](#removed-4) -- [v1.19.0-rc.4](#v1190-rc4) - - [Downloads for v1.19.0-rc.4](#downloads-for-v1190-rc4) - - [Source Code](#source-code-3) - - [Client binaries](#client-binaries-4) - - [Server binaries](#server-binaries-4) - - [Node binaries](#node-binaries-4) - - [Changelog since v1.19.0-rc.3](#changelog-since-v1190-rc3) - - [Changes by Kind](#changes-by-kind-4) - - [Deprecation](#deprecation-1) - - [Bug or Regression](#bug-or-regression-4) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-4) - [Dependencies](#dependencies-5) - [Added](#added-5) - [Changed](#changed-5) - [Removed](#removed-5) -- [v1.19.0-rc.3](#v1190-rc3) - - [Downloads for v1.19.0-rc.3](#downloads-for-v1190-rc3) +- [v1.19.0-rc.4](#v1190-rc4) + - [Downloads for v1.19.0-rc.4](#downloads-for-v1190-rc4) - [Source Code](#source-code-4) - [Client binaries](#client-binaries-5) - [Server binaries](#server-binaries-5) - [Node binaries](#node-binaries-5) - - [Changelog since v1.19.0-rc.2](#changelog-since-v1190-rc2) + - [Changelog since v1.19.0-rc.3](#changelog-since-v1190-rc3) - [Changes by Kind](#changes-by-kind-5) - - [API Change](#api-change-2) + - [Deprecation](#deprecation-1) - [Bug or Regression](#bug-or-regression-5) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-4) - [Dependencies](#dependencies-6) - [Added](#added-6) - [Changed](#changed-6) - [Removed](#removed-6) -- [v1.19.0-rc.2](#v1190-rc2) - - [Downloads for v1.19.0-rc.2](#downloads-for-v1190-rc2) +- [v1.19.0-rc.3](#v1190-rc3) + - [Downloads for v1.19.0-rc.3](#downloads-for-v1190-rc3) - [Source Code](#source-code-5) - [Client binaries](#client-binaries-6) - [Server binaries](#server-binaries-6) - [Node binaries](#node-binaries-6) - - [Changelog since v1.19.0-rc.1](#changelog-since-v1190-rc1) + - [Changelog since v1.19.0-rc.2](#changelog-since-v1190-rc2) - [Changes by Kind](#changes-by-kind-6) - - [API Change](#api-change-3) - - [Feature](#feature-2) + - [API Change](#api-change-2) - [Bug or Regression](#bug-or-regression-6) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-5) - [Dependencies](#dependencies-7) - [Added](#added-7) - [Changed](#changed-7) - [Removed](#removed-7) -- [v1.19.0-rc.1](#v1190-rc1) - - [Downloads for v1.19.0-rc.1](#downloads-for-v1190-rc1) +- [v1.19.0-rc.2](#v1190-rc2) + - [Downloads for v1.19.0-rc.2](#downloads-for-v1190-rc2) - [Source Code](#source-code-6) - [Client binaries](#client-binaries-7) - [Server binaries](#server-binaries-7) - [Node binaries](#node-binaries-7) - - [Changelog since v1.19.0-rc.0](#changelog-since-v1190-rc0) - - [Urgent Upgrade Notes](#urgent-upgrade-notes) - - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-1) + - [Changelog since v1.19.0-rc.1](#changelog-since-v1190-rc1) - [Changes by Kind](#changes-by-kind-7) - - [Deprecation](#deprecation-2) - - [API Change](#api-change-4) - - [Feature](#feature-3) - - [Failing Test](#failing-test-1) + - [API Change](#api-change-3) + - [Feature](#feature-2) - [Bug or Regression](#bug-or-regression-7) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-6) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-5) - [Dependencies](#dependencies-8) - [Added](#added-8) - [Changed](#changed-8) - [Removed](#removed-8) -- [v1.19.0-beta.2](#v1190-beta2) - - [Downloads for v1.19.0-beta.2](#downloads-for-v1190-beta2) +- [v1.19.0-rc.1](#v1190-rc1) + - [Downloads for v1.19.0-rc.1](#downloads-for-v1190-rc1) - [Source Code](#source-code-7) - [Client binaries](#client-binaries-8) - [Server binaries](#server-binaries-8) - [Node binaries](#node-binaries-8) - - [Changelog since v1.19.0-beta.1](#changelog-since-v1190-beta1) + - [Changelog since v1.19.0-rc.0](#changelog-since-v1190-rc0) + - [Urgent Upgrade Notes](#urgent-upgrade-notes-1) + - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-1) - [Changes by Kind](#changes-by-kind-8) - - [Deprecation](#deprecation-3) - - [API Change](#api-change-5) - - [Feature](#feature-4) + - [Deprecation](#deprecation-2) + - [API Change](#api-change-4) + - [Feature](#feature-3) + - [Failing Test](#failing-test-1) - [Bug or Regression](#bug-or-regression-8) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-7) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-6) - [Dependencies](#dependencies-9) - [Added](#added-9) - [Changed](#changed-9) - [Removed](#removed-9) -- [v1.19.0-beta.1](#v1190-beta1) - - [Downloads for v1.19.0-beta.1](#downloads-for-v1190-beta1) +- [v1.19.0-beta.2](#v1190-beta2) + - [Downloads for v1.19.0-beta.2](#downloads-for-v1190-beta2) - [Source Code](#source-code-8) - [Client binaries](#client-binaries-9) - [Server binaries](#server-binaries-9) - [Node binaries](#node-binaries-9) - - [Changelog since v1.19.0-alpha.3](#changelog-since-v1190-alpha3) - - [Urgent Upgrade Notes](#urgent-upgrade-notes-1) - - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-2) + - [Changelog since v1.19.0-beta.1](#changelog-since-v1190-beta1) - [Changes by Kind](#changes-by-kind-9) - - [API Change](#api-change-6) - - [Feature](#feature-5) + - [Deprecation](#deprecation-3) + - [API Change](#api-change-5) + - [Feature](#feature-4) - [Bug or Regression](#bug-or-regression-9) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-8) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-7) - [Dependencies](#dependencies-10) - [Added](#added-10) - [Changed](#changed-10) - [Removed](#removed-10) -- [v1.19.0-beta.0](#v1190-beta0) - - [Downloads for v1.19.0-beta.0](#downloads-for-v1190-beta0) +- [v1.19.0-beta.1](#v1190-beta1) + - [Downloads for v1.19.0-beta.1](#downloads-for-v1190-beta1) - [Source Code](#source-code-9) - [Client binaries](#client-binaries-10) - [Server binaries](#server-binaries-10) - [Node binaries](#node-binaries-10) - - [Changelog since v1.19.0-alpha.3](#changelog-since-v1190-alpha3-1) + - [Changelog since v1.19.0-alpha.3](#changelog-since-v1190-alpha3) + - [Urgent Upgrade Notes](#urgent-upgrade-notes-2) + - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-2) - [Changes by Kind](#changes-by-kind-10) - - [API Change](#api-change-7) - - [Feature](#feature-6) + - [API Change](#api-change-6) + - [Feature](#feature-5) - [Bug or Regression](#bug-or-regression-10) - - [Other (Cleanup or Flake)](#other-cleanup-or-flake-9) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-8) - [Dependencies](#dependencies-11) - [Added](#added-11) - [Changed](#changed-11) - [Removed](#removed-11) +- [v1.19.0-beta.0](#v1190-beta0) + - [Downloads for v1.19.0-beta.0](#downloads-for-v1190-beta0) + - [Source Code](#source-code-10) + - [Client binaries](#client-binaries-11) + - [Server binaries](#server-binaries-11) + - [Node binaries](#node-binaries-11) + - [Changelog since v1.19.0-alpha.3](#changelog-since-v1190-alpha3-1) + - [Changes by Kind](#changes-by-kind-11) + - [API Change](#api-change-7) + - [Feature](#feature-6) + - [Bug or Regression](#bug-or-regression-11) + - [Other (Cleanup or Flake)](#other-cleanup-or-flake-9) + - [Dependencies](#dependencies-12) + - [Added](#added-12) + - [Changed](#changed-12) + - [Removed](#removed-12) - [v1.19.0-alpha.3](#v1190-alpha3) - [Downloads for v1.19.0-alpha.3](#downloads-for-v1190-alpha3) - - [Client Binaries](#client-binaries-11) - - [Server Binaries](#server-binaries-11) - - [Node Binaries](#node-binaries-11) + - [Client Binaries](#client-binaries-12) + - [Server Binaries](#server-binaries-12) + - [Node Binaries](#node-binaries-12) - [Changelog since v1.19.0-alpha.2](#changelog-since-v1190-alpha2) - - [Urgent Upgrade Notes](#urgent-upgrade-notes-2) + - [Urgent Upgrade Notes](#urgent-upgrade-notes-3) - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-3) - - [Changes by Kind](#changes-by-kind-11) + - [Changes by Kind](#changes-by-kind-12) - [Deprecation](#deprecation-4) - [API Change](#api-change-8) - [Feature](#feature-7) - - [Bug or Regression](#bug-or-regression-11) + - [Bug or Regression](#bug-or-regression-12) - [Other (Cleanup or Flake)](#other-cleanup-or-flake-10) - [v1.19.0-alpha.2](#v1190-alpha2) - [Downloads for v1.19.0-alpha.2](#downloads-for-v1190-alpha2) - - [Client Binaries](#client-binaries-12) - - [Server Binaries](#server-binaries-12) - - [Node Binaries](#node-binaries-12) + - [Client Binaries](#client-binaries-13) + - [Server Binaries](#server-binaries-13) + - [Node Binaries](#node-binaries-13) - [Changelog since v1.19.0-alpha.1](#changelog-since-v1190-alpha1) - - [Urgent Upgrade Notes](#urgent-upgrade-notes-3) + - [Urgent Upgrade Notes](#urgent-upgrade-notes-4) - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-4) - - [Changes by Kind](#changes-by-kind-12) + - [Changes by Kind](#changes-by-kind-13) - [API Change](#api-change-9) - [Feature](#feature-8) - - [Bug or Regression](#bug-or-regression-12) + - [Bug or Regression](#bug-or-regression-13) - [Other (Cleanup or Flake)](#other-cleanup-or-flake-11) - [v1.19.0-alpha.1](#v1190-alpha1) - [Downloads for v1.19.0-alpha.1](#downloads-for-v1190-alpha1) - - [Client Binaries](#client-binaries-13) - - [Server Binaries](#server-binaries-13) - - [Node Binaries](#node-binaries-13) + - [Client Binaries](#client-binaries-14) + - [Server Binaries](#server-binaries-14) + - [Node Binaries](#node-binaries-14) - [Changelog since v1.19.0-alpha.0](#changelog-since-v1190-alpha0) - - [Urgent Upgrade Notes](#urgent-upgrade-notes-4) + - [Urgent Upgrade Notes](#urgent-upgrade-notes-5) - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade-5) - - [Changes by Kind](#changes-by-kind-13) + - [Changes by Kind](#changes-by-kind-14) - [Deprecation](#deprecation-5) - [API Change](#api-change-10) + - [Feature](#feature-9) + - [Documentation](#documentation-1) + - [Other (Bug, Cleanup or Flake)](#other-bug-cleanup-or-flake) +# v1.19.4 + + +## Downloads for v1.19.4 + +### Source Code + +filename | sha512 hash +-------- | ----------- +[kubernetes.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes.tar.gz) | ddd4ef04975492c39a8ecb469c1d0ccf3c4321be2cd6d03e2d64e292e3e5b4ef5430ccd78c4495a93794f5268a1e09f8636778eba74939414831be60697218b4 +[kubernetes-src.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-src.tar.gz) | ead6d115cc763b86388ddd3e0cbb5ceb6556478d562601beb5bc4ec7c432cfcf7e83e3b20c06532b6231e03efa483079779549e217b3172e4e648462a77f0e00 + +### Client binaries + +filename | sha512 hash +-------- | ----------- +[kubernetes-client-darwin-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-darwin-amd64.tar.gz) | 8529a8052466b642eba64f2ace3d2ea10689635c1b598c7ea822609ccdf1042f0f672b5c081d46f17a33554a4f776919f84bf25ec391466581e53efc3d9533b4 +[kubernetes-client-linux-386.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-386.tar.gz) | 7334e42e4c8fec3b9b081dd2b2b58496cfc802c413546fd9013c75800d02b88688b0322d8e6586ea990bb31286b43f56ca24ff57cbe53624190500e94ba85414 +[kubernetes-client-linux-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-amd64.tar.gz) | 7e65358a19b4eabfbbf886061098d7edc1268ab59a3e0f813a264ff525bed8c76f4f0bd5bcb151d8a05dcb1b2f25d874e2346d448725e701614439a27f960079 +[kubernetes-client-linux-arm.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-arm.tar.gz) | 07bbef417d97b6f7abf82dc421c0caad7662d4f63d524e20bb39eb0b73d9dea539886dea273160153a7b8ec871d5710884a46a368a316ec79bbe5c00593f1448 +[kubernetes-client-linux-arm64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-arm64.tar.gz) | 5097fc45eff3bf9d83443f7bf4e96b28b9f5836770bba8cf9a08b0278306d91b1b1a83f9c4d8808db6c1242357cc42043116f508499b256d578f972193cb5911 +[kubernetes-client-linux-ppc64le.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-ppc64le.tar.gz) | 93157ffa9ca39d46c54573914400e65ebd79fb10b0e638e1793958c68f413a3f7bfe2791fe9eaa5cc5ff440833f9f94009c54e5622accc1e392c94054779b7b6 +[kubernetes-client-linux-s390x.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-linux-s390x.tar.gz) | 0ef55f8461c66df50b7dc208d2e109787c3badb0d400700f823f6c55f37344bb4e78f15006eadd8b269e296a2cdfff045a49a3d2e715fa4a17e429aba1ba1c1c +[kubernetes-client-windows-386.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-windows-386.tar.gz) | 60b25d5a78bb1ecb00b6ab756a68730b533e580e62b3a30ca9126a392c25990291d71b367db2768dd53a9738498b4781b0c9534228f635e1cbbb9362f792f51c +[kubernetes-client-windows-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-client-windows-amd64.tar.gz) | df81925afab37ef5f106b401a0f0a54f3f6fdc1dde1e7e0f5a49e335cfd92d3fba07289df9eac09c3972890192d85a5f279777a9f02d175d75c5d1c85eca8ab4 + +### Server binaries + +filename | sha512 hash +-------- | ----------- +[kubernetes-server-linux-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-server-linux-amd64.tar.gz) | fc9de14121af682af167ef99ce8a3803c25e92ef4739ed7eb592eadb30086b2cb9ede51d57816d1c3835f6202753d726eba804b839ae9cd516eff4e94c81c189 +[kubernetes-server-linux-arm.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-server-linux-arm.tar.gz) | f18432d7bcaa3624c1b08e2c6a7c01dbf09eff4f6345e2610ecc5cd6cfd7abe3eaf570d8a02db0b0e06355705b435309eff7d15b23094383974916a8aeb33a96 +[kubernetes-server-linux-arm64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-server-linux-arm64.tar.gz) | 84c717ee35584c34f68653579b46ec69d9d6737b6d2a654870c1855813ef3eef858bc9499feee85558095703acebb09a7386491a0cafe70fc6c6c4acf603e064 +[kubernetes-server-linux-ppc64le.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-server-linux-ppc64le.tar.gz) | 68ac30c0b5a7e5262e42be0e373f3a86de40d5b9ff1a3f5fc6302ce3e1d5bf6619dbeaef7dc36632854e3241c5d11b85450e619e75baf01709e4cc94544783b9 +[kubernetes-server-linux-s390x.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-server-linux-s390x.tar.gz) | dd794887a5f42a37ebaa9d36b9377880a3daffd4fac8617dd221c0c551439bcb94c13697c9292458eb0797b142e752b22b3182212ecb1b8d80e9f1918cc72e7b + +### Node binaries + +filename | sha512 hash +-------- | ----------- +[kubernetes-node-linux-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-linux-amd64.tar.gz) | 6ce43d84df8b983c9294b05c7d2cbd2ec1286c2055e5719de983b4b85e95dcb1adb4baa5269a2ee3e392e3ace093b22c409fade113057a2af01d3ab50c660806 +[kubernetes-node-linux-arm.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-linux-arm.tar.gz) | f7ee10926074061e1132db7f6e5aa29b1c98e51b9327fd1d046ca3ac0556288edf73dd06da0009c107cc25a3103f6642d347183f0abe210a3193b488bc6f4b12 +[kubernetes-node-linux-arm64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-linux-arm64.tar.gz) | 55882683ec94628770e8744317fb0719f394b026728a0efbb608b39fdefb60d290f550580be1e24b4bf001de4ccd3e0ae1faa7b73e02355473384124f1857d29 +[kubernetes-node-linux-ppc64le.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-linux-ppc64le.tar.gz) | 3aa9dc9decd5bfa67c9cf6cae27061ead769d18f7918d2ce6db51efa5dfe0a7dfef93415d2578bc6e6693ff3da6e22e32decb1e27b7dba52744e800c040aa690 +[kubernetes-node-linux-s390x.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-linux-s390x.tar.gz) | 7c160cfb2ed1b15808c1b27fee85c125fc96809c7cd283bd982b7513bcdc1a19ae39cdd946bf637d83982bdc82de90f4e81b3ebbdf076e1696532c04e60d2cdc +[kubernetes-node-windows-amd64.tar.gz](https://dl.k8s.io/v1.19.4/kubernetes-node-windows-amd64.tar.gz) | 403fe541e01d45628aac943af6e5df14316391d91c0afdac731b6e21377afeae220de016e0073a2285c1ed6280ead67c46da0e9da47ca2363c58127d62612262 + +## Changelog since v1.19.3 + +## Changes by Kind + +### Bug or Regression + +- An issues preventing volume expand controller to annotate the PVC with `volume.kubernetes.io/storage-resizer` when the PVC StorageClass is already updated to the out-of-tree provisioner is now fixed. ([#94489](https://github.com/kubernetes/kubernetes/pull/94489), [@ialidzhikov](https://github.com/ialidzhikov)) [SIG API Machinery, Apps and Storage] +- Cloud node controller: handle empty providerID from getProviderID ([#95452](https://github.com/kubernetes/kubernetes/pull/95452), [@nicolehanjing](https://github.com/nicolehanjing)) [SIG Cloud Provider] +- Disable watchcache for events ([#96052](https://github.com/kubernetes/kubernetes/pull/96052), [@wojtek-t](https://github.com/wojtek-t)) [SIG API Machinery] +- Disabled `LocalStorageCapacityIsolation` feature gate is honored during scheduling. ([#96140](https://github.com/kubernetes/kubernetes/pull/96140), [@Huang-Wei](https://github.com/Huang-Wei)) [SIG Scheduling] +- Fix a bug that Pods with topologySpreadConstraints get scheduled to nodes without required labels. ([#95880](https://github.com/kubernetes/kubernetes/pull/95880), [@ialidzhikov](https://github.com/ialidzhikov)) [SIG Scheduling] +- Fix azure disk attach failure for disk size bigger than 4TB ([#95463](https://github.com/kubernetes/kubernetes/pull/95463), [@andyzhangx](https://github.com/andyzhangx)) [SIG Cloud Provider] +- Fix azure disk data loss issue on Windows when unmount disk ([#95456](https://github.com/kubernetes/kubernetes/pull/95456), [@andyzhangx](https://github.com/andyzhangx)) [SIG Cloud Provider and Storage] +- Fixed a bug causing incorrect formatting of `kubectl describe ingress`. ([#94985](https://github.com/kubernetes/kubernetes/pull/94985), [@howardjohn](https://github.com/howardjohn)) [SIG CLI and Network] +- Fixed a bug in client-go where new clients with customized `Dial`, `Proxy`, `GetCert` config may get stale HTTP transports. ([#95427](https://github.com/kubernetes/kubernetes/pull/95427), [@roycaihw](https://github.com/roycaihw)) [SIG API Machinery] +- Fixed a regression which prevented pods with `docker/default` seccomp annotations from being created in 1.19 if a PodSecurityPolicy was in place which did not allow `runtime/default` seccomp profiles. ([#95990](https://github.com/kubernetes/kubernetes/pull/95990), [@saschagrunert](https://github.com/saschagrunert)) [SIG Auth] +- Fixed kubelet creating extra sandbox for pods with RestartPolicyOnFailure after all containers succeeded ([#92614](https://github.com/kubernetes/kubernetes/pull/92614), [@tnqn](https://github.com/tnqn)) [SIG Node and Testing] +- Fixes high CPU usage in kubectl drain ([#95260](https://github.com/kubernetes/kubernetes/pull/95260), [@amandahla](https://github.com/amandahla)) [SIG CLI] +- If we set SelectPolicy MinPolicySelect on scaleUp behavior or scaleDown behavior,Horizontal Pod Autoscaler doesn`t automatically scale the number of pods correctly ([#95647](https://github.com/kubernetes/kubernetes/pull/95647), [@JoshuaAndrew](https://github.com/JoshuaAndrew)) [SIG Apps and Autoscaling] +- Kube-proxy now trims extra spaces found in loadBalancerSourceRanges to match Service validation. ([#94107](https://github.com/kubernetes/kubernetes/pull/94107), [@robscott](https://github.com/robscott)) [SIG Network] +- Kubeadm: add missing "--experimental-patches" flag to "kubeadm init phase control-plane" ([#95786](https://github.com/kubernetes/kubernetes/pull/95786), [@Sh4d1](https://github.com/Sh4d1)) [SIG Cluster Lifecycle] + +## Dependencies + +### Added +_Nothing has changed._ + +### Changed +_Nothing has changed._ + +### Removed +_Nothing has changed._ + + + # v1.19.3 From dea9e917b25da34ef299bf0fc438a34c37efa3e0 Mon Sep 17 00:00:00 2001 From: Wei Huang Date: Tue, 10 Nov 2020 17:46:37 -0800 Subject: [PATCH 017/301] Fix a bug that DefaultPreemption plugin is disabled when using scheduler policy --- cmd/kube-scheduler/app/server_test.go | 1 + pkg/scheduler/BUILD | 2 ++ .../apis/config/testing/compatibility_test.go | 25 +++++++++++++++---- pkg/scheduler/factory.go | 6 ++++- pkg/scheduler/factory_test.go | 6 +++++ test/integration/scheduler/scheduler_test.go | 10 ++++++-- 6 files changed, 42 insertions(+), 8 deletions(-) diff --git a/cmd/kube-scheduler/app/server_test.go b/cmd/kube-scheduler/app/server_test.go index 37fd74a154955..90adf19fba460 100644 --- a/cmd/kube-scheduler/app/server_test.go +++ b/cmd/kube-scheduler/app/server_test.go @@ -351,6 +351,7 @@ profiles: {Name: "TaintToleration"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, }, diff --git a/pkg/scheduler/BUILD b/pkg/scheduler/BUILD index f6f77557d8541..49d1785867dea 100644 --- a/pkg/scheduler/BUILD +++ b/pkg/scheduler/BUILD @@ -19,6 +19,7 @@ go_library( "//pkg/scheduler/core:go_default_library", "//pkg/scheduler/framework/plugins:go_default_library", "//pkg/scheduler/framework/plugins/defaultbinder:go_default_library", + "//pkg/scheduler/framework/plugins/defaultpreemption:go_default_library", "//pkg/scheduler/framework/plugins/noderesources:go_default_library", "//pkg/scheduler/framework/plugins/queuesort:go_default_library", "//pkg/scheduler/framework/runtime:go_default_library", @@ -65,6 +66,7 @@ go_test( "//pkg/scheduler/core:go_default_library", "//pkg/scheduler/framework/plugins:go_default_library", "//pkg/scheduler/framework/plugins/defaultbinder:go_default_library", + "//pkg/scheduler/framework/plugins/defaultpreemption:go_default_library", "//pkg/scheduler/framework/plugins/interpodaffinity:go_default_library", "//pkg/scheduler/framework/plugins/nodelabel:go_default_library", "//pkg/scheduler/framework/plugins/nodeports:go_default_library", diff --git a/pkg/scheduler/apis/config/testing/compatibility_test.go b/pkg/scheduler/apis/config/testing/compatibility_test.go index 18644c422edb9..689c6a2061cec 100644 --- a/pkg/scheduler/apis/config/testing/compatibility_test.go +++ b/pkg/scheduler/apis/config/testing/compatibility_test.go @@ -75,7 +75,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "NodeAffinity"}, {Name: "TaintToleration"}, }, - "BindPlugin": {{Name: "DefaultBinder"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "BindPlugin": {{Name: "DefaultBinder"}}, }, }, // This is a special test for the case where a policy is specified without specifying any filters. @@ -95,7 +96,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "NodeUnschedulable"}, {Name: "TaintToleration"}, }, - "BindPlugin": {{Name: "DefaultBinder"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "BindPlugin": {{Name: "DefaultBinder"}}, }, }, // Do not change this JSON after the corresponding release has been tagged. @@ -136,7 +138,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "NodeLabel"}, {Name: "ServiceAffinity"}, }, - "PreScorePlugin": {{Name: "SelectorSpread"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "PreScorePlugin": {{Name: "SelectorSpread"}}, "ScorePlugin": { {Name: "NodeResourcesLeastAllocated", Weight: 1}, {Name: "NodeLabel", Weight: 4}, @@ -191,7 +194,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "NodeLabel"}, {Name: "ServiceAffinity"}, }, - "PreScorePlugin": {{Name: "SelectorSpread"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "PreScorePlugin": {{Name: "SelectorSpread"}}, "ScorePlugin": { {Name: "NodeResourcesBalancedAllocation", Weight: 2}, {Name: "NodeResourcesLeastAllocated", Weight: 2}, @@ -254,7 +258,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "AzureDiskLimits"}, {Name: "VolumeZone"}, }, - "PreScorePlugin": {{Name: "SelectorSpread"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "PreScorePlugin": {{Name: "SelectorSpread"}}, "ScorePlugin": { {Name: "NodeResourcesBalancedAllocation", Weight: 2}, {Name: "ImageLocality", Weight: 2}, @@ -324,6 +329,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -400,6 +406,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -487,6 +494,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -585,6 +593,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -686,6 +695,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -792,6 +802,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -910,6 +921,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -1031,6 +1043,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -1152,6 +1165,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, @@ -1277,6 +1291,7 @@ func TestCompatibility_v1_Scheduler(t *testing.T) { {Name: "VolumeZone"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "InterPodAffinity"}, {Name: "SelectorSpread"}, diff --git a/pkg/scheduler/factory.go b/pkg/scheduler/factory.go index 8165968d28a01..05489680ca8e5 100644 --- a/pkg/scheduler/factory.go +++ b/pkg/scheduler/factory.go @@ -42,6 +42,7 @@ import ( "k8s.io/kubernetes/pkg/scheduler/core" frameworkplugins "k8s.io/kubernetes/pkg/scheduler/framework/plugins" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder" + "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultpreemption" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/noderesources" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort" frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime" @@ -290,12 +291,15 @@ func (c *Configurator) createFromConfig(policy schedulerapi.Policy) (*Scheduler, // Combine all framework configurations. If this results in any duplication, framework // instantiation should fail. var defPlugins schedulerapi.Plugins - // "PrioritySort" and "DefaultBinder" were neither predicates nor priorities + // "PrioritySort", "DefaultPreemption" and "DefaultBinder" were neither predicates nor priorities // before. We add them by default. defPlugins.Append(&schedulerapi.Plugins{ QueueSort: &schedulerapi.PluginSet{ Enabled: []schedulerapi.Plugin{{Name: queuesort.Name}}, }, + PostFilter: &schedulerapi.PluginSet{ + Enabled: []schedulerapi.Plugin{{Name: defaultpreemption.Name}}, + }, Bind: &schedulerapi.PluginSet{ Enabled: []schedulerapi.Plugin{{Name: defaultbinder.Name}}, }, diff --git a/pkg/scheduler/factory_test.go b/pkg/scheduler/factory_test.go index 3ab7608945bdf..2335c667f70ef 100644 --- a/pkg/scheduler/factory_test.go +++ b/pkg/scheduler/factory_test.go @@ -40,6 +40,7 @@ import ( "k8s.io/kubernetes/pkg/scheduler/apis/config/scheme" frameworkplugins "k8s.io/kubernetes/pkg/scheduler/framework/plugins" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder" + "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultpreemption" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/interpodaffinity" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/nodelabel" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort" @@ -113,6 +114,11 @@ func TestCreateFromConfig(t *testing.T) { if diff := cmp.Diff(wantQueuePls, queueSortPls); diff != "" { t.Errorf("Unexpected QueueSort plugins (-want, +got): %s", diff) } + postFilterPls := prof.ListPlugins()["PostFilterPlugin"] + wantPostFilterPls := []schedulerapi.Plugin{{Name: defaultpreemption.Name}} + if diff := cmp.Diff(wantPostFilterPls, postFilterPls); diff != "" { + t.Errorf("Unexpected PostFilter plugins (-want, +got): %s", diff) + } bindPls := prof.ListPlugins()["BindPlugin"] wantBindPls := []schedulerapi.Plugin{{Name: defaultbinder.Name}} if diff := cmp.Diff(wantBindPls, bindPls); diff != "" { diff --git a/test/integration/scheduler/scheduler_test.go b/test/integration/scheduler/scheduler_test.go index 4b15ffcc9ff12..0cc7e7f46bb03 100644 --- a/test/integration/scheduler/scheduler_test.go +++ b/test/integration/scheduler/scheduler_test.go @@ -91,6 +91,7 @@ func TestSchedulerCreationFromConfigMap(t *testing.T) { {Name: "NodeResourcesFit"}, {Name: "TaintToleration"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "ScorePlugin": { {Name: "ImageLocality", Weight: 1}, }, @@ -128,6 +129,7 @@ func TestSchedulerCreationFromConfigMap(t *testing.T) { {Name: "PodTopologySpread"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "PodTopologySpread"}, {Name: "InterPodAffinity"}, @@ -163,7 +165,8 @@ func TestSchedulerCreationFromConfigMap(t *testing.T) { {Name: "NodeUnschedulable"}, {Name: "TaintToleration"}, }, - "BindPlugin": {{Name: "DefaultBinder"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "BindPlugin": {{Name: "DefaultBinder"}}, }, }, { @@ -185,6 +188,7 @@ priorities: {Name: "NodeResourcesFit"}, {Name: "TaintToleration"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "ScorePlugin": { {Name: "ImageLocality", Weight: 1}, }, @@ -221,6 +225,7 @@ kind: Policy {Name: "PodTopologySpread"}, {Name: "InterPodAffinity"}, }, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, "PreScorePlugin": { {Name: "PodTopologySpread"}, {Name: "InterPodAffinity"}, @@ -255,7 +260,8 @@ priorities: [] {Name: "NodeUnschedulable"}, {Name: "TaintToleration"}, }, - "BindPlugin": {{Name: "DefaultBinder"}}, + "PostFilterPlugin": {{Name: "DefaultPreemption"}}, + "BindPlugin": {{Name: "DefaultBinder"}}, }, }, } { From c7b1e3d756634cff80efae176cbbc66ea551405d Mon Sep 17 00:00:00 2001 From: jornshen Date: Tue, 27 Oct 2020 10:36:29 +0800 Subject: [PATCH 018/301] change GetFullQualifiedPluginNameForVolume to distinuish different drivers Change-Id: Iaeafa67215565f7f4906fc2b683c8a231bee8e90 --- pkg/volume/util/BUILD | 3 ++ pkg/volume/util/metrics.go | 11 +++- pkg/volume/util/metrics_test.go | 91 +++++++++++++++++++++++++++++++++ 3 files changed, 103 insertions(+), 2 deletions(-) create mode 100644 pkg/volume/util/metrics_test.go diff --git a/pkg/volume/util/BUILD b/pkg/volume/util/BUILD index 8cb989f7ae72c..8f615f069e67a 100644 --- a/pkg/volume/util/BUILD +++ b/pkg/volume/util/BUILD @@ -22,6 +22,7 @@ go_library( "//pkg/api/legacyscheme:go_default_library", "//pkg/api/v1/pod:go_default_library", "//pkg/apis/core/v1/helper:go_default_library", + "//pkg/features:go_default_library", "//pkg/securitycontext:go_default_library", "//pkg/util/resizefs:go_default_library", "//pkg/volume:go_default_library", @@ -38,6 +39,7 @@ go_library( "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/strategicpatch:go_default_library", + "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", "//staging/src/k8s.io/client-go/kubernetes:go_default_library", "//staging/src/k8s.io/component-base/metrics:go_default_library", "//staging/src/k8s.io/component-base/metrics/legacyregistry:go_default_library", @@ -54,6 +56,7 @@ go_test( "atomic_writer_test.go", "attach_limit_test.go", "device_util_linux_test.go", + "metrics_test.go", "nested_volumes_test.go", "resize_util_test.go", "util_test.go", diff --git a/pkg/volume/util/metrics.go b/pkg/volume/util/metrics.go index 5542f8e534b88..522c9420ee9c3 100644 --- a/pkg/volume/util/metrics.go +++ b/pkg/volume/util/metrics.go @@ -20,8 +20,10 @@ import ( "fmt" "time" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/component-base/metrics" "k8s.io/component-base/metrics/legacyregistry" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/volume" ) @@ -115,8 +117,13 @@ func OperationCompleteHook(plugin, operationName string) func(*error) { // between metrics emitted for CSI volumes which may be handled by different // CSI plugin drivers. func GetFullQualifiedPluginNameForVolume(pluginName string, spec *volume.Spec) string { - if spec != nil && spec.PersistentVolume != nil && spec.PersistentVolume.Spec.CSI != nil { - return fmt.Sprintf("%s:%s", pluginName, spec.PersistentVolume.Spec.CSI.Driver) + if spec != nil { + if spec.Volume != nil && spec.Volume.CSI != nil && utilfeature.DefaultFeatureGate.Enabled(features.CSIInlineVolume) { + return fmt.Sprintf("%s:%s", pluginName, spec.Volume.CSI.Driver) + } + if spec.PersistentVolume != nil && spec.PersistentVolume.Spec.CSI != nil { + return fmt.Sprintf("%s:%s", pluginName, spec.PersistentVolume.Spec.CSI.Driver) + } } return pluginName } diff --git a/pkg/volume/util/metrics_test.go b/pkg/volume/util/metrics_test.go new file mode 100644 index 0000000000000..ed450b7e36d6b --- /dev/null +++ b/pkg/volume/util/metrics_test.go @@ -0,0 +1,91 @@ +/* +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 util + +import ( + "fmt" + "testing" + + v1 "k8s.io/api/core/v1" + "k8s.io/kubernetes/pkg/volume" +) + +func TestGetFullQualifiedPluginNameForVolume(t *testing.T) { + var ( + fakePluginName = "kubernetes.io/fakePlugin" + fakeInlineCSIDriverName = "fake.inline.csi.driver" + fakeCSIDriverName = "fake.csi.driver" + ) + + testCase := []struct { + name string + pluginName string + spec *volume.Spec + wantFullName string + }{ + { + name: "get full qualified plugin name without volume spec", + pluginName: fakePluginName, + spec: nil, + wantFullName: fakePluginName, + }, + { + name: "get full qualified plugin name without using CSI plugin", + pluginName: fakePluginName, + spec: &volume.Spec{}, + wantFullName: fakePluginName, + }, + { + name: "get full qualified plugin name with CSI ephemeral volume", + pluginName: fakePluginName, + spec: &volume.Spec{ + Volume: &v1.Volume{ + VolumeSource: v1.VolumeSource{ + CSI: &v1.CSIVolumeSource{ + Driver: fakeInlineCSIDriverName, + }, + }, + }, + }, + wantFullName: fmt.Sprintf("%s:%s", fakePluginName, fakeInlineCSIDriverName), + }, + { + name: "get full qualified plugin name with CSI PV", + pluginName: fakePluginName, + spec: &volume.Spec{ + PersistentVolume: &v1.PersistentVolume{ + Spec: v1.PersistentVolumeSpec{ + PersistentVolumeSource: v1.PersistentVolumeSource{ + CSI: &v1.CSIPersistentVolumeSource{ + Driver: fakeCSIDriverName, + }, + }, + }, + }, + }, + wantFullName: fmt.Sprintf("%s:%s", fakePluginName, fakeCSIDriverName), + }, + } + + for _, test := range testCase { + t.Run(test.name, func(t *testing.T) { + if fullPluginName := GetFullQualifiedPluginNameForVolume(test.pluginName, test.spec); fullPluginName != test.wantFullName { + t.Errorf("Case name: %s, GetFullQualifiedPluginNameForVolume, pluginName:%s, spec: %v, return:%s, want:%s", test.name, test.pluginName, test.spec, fullPluginName, test.wantFullName) + } + }) + } +} From eccd891f65b5a075d64bf10f64fea8cacc9cb575 Mon Sep 17 00:00:00 2001 From: Lion-Wei Date: Sat, 19 Sep 2020 17:44:38 +0800 Subject: [PATCH 019/301] fix kube-proxy cleanup --- cmd/kube-proxy/app/server.go | 17 +++++++++--- cmd/kube-proxy/app/server_others.go | 43 ++++++++++++++--------------- 2 files changed, 34 insertions(+), 26 deletions(-) diff --git a/cmd/kube-proxy/app/server.go b/cmd/kube-proxy/app/server.go index c5739efd11b8b..b4293c05cee70 100644 --- a/cmd/kube-proxy/app/server.go +++ b/cmd/kube-proxy/app/server.go @@ -801,11 +801,20 @@ func getConntrackMax(config kubeproxyconfig.KubeProxyConntrackConfiguration) (in return 0, nil } -// CleanupAndExit remove iptables rules and exit if success return nil +// CleanupAndExit remove iptables rules and ipset/ipvs rules in ipvs proxy mode +// and exit if success return nil func (s *ProxyServer) CleanupAndExit() error { - encounteredError := userspace.CleanupLeftovers(s.IptInterface) - encounteredError = iptables.CleanupLeftovers(s.IptInterface) || encounteredError - encounteredError = ipvs.CleanupLeftovers(s.IpvsInterface, s.IptInterface, s.IpsetInterface, s.CleanupIPVS) || encounteredError + // cleanup IPv6 and IPv4 iptables rules + ipts := []utiliptables.Interface{ + utiliptables.New(s.execer, utiliptables.ProtocolIPv4), + utiliptables.New(s.execer, utiliptables.ProtocolIPv6), + } + var encounteredError bool + for _, ipt := range ipts { + encounteredError = userspace.CleanupLeftovers(ipt) || encounteredError + encounteredError = iptables.CleanupLeftovers(ipt) || encounteredError + encounteredError = ipvs.CleanupLeftovers(s.IpvsInterface, ipt, s.IpsetInterface, s.CleanupIPVS) || encounteredError + } if encounteredError { return errors.New("encountered an error while tearing down rules") } diff --git a/cmd/kube-proxy/app/server_others.go b/cmd/kube-proxy/app/server_others.go index eb69ea27fb916..614dd61d460f5 100644 --- a/cmd/kube-proxy/app/server_others.go +++ b/cmd/kube-proxy/app/server_others.go @@ -91,26 +91,6 @@ func newProxyServer( return nil, fmt.Errorf("unable to register configz: %s", err) } - hostname, err := utilnode.GetHostname(config.HostnameOverride) - if err != nil { - return nil, err - } - - client, eventClient, err := createClients(config.ClientConnection, master) - if err != nil { - return nil, err - } - - nodeIP := detectNodeIP(client, hostname, config.BindAddress) - - protocol := utiliptables.ProtocolIPv4 - if utilsnet.IsIPv6(nodeIP) { - klog.V(0).Infof("kube-proxy node IP is an IPv6 address (%s), assume IPv6 operation", nodeIP.String()) - protocol = utiliptables.ProtocolIPv6 - } else { - klog.V(0).Infof("kube-proxy node IP is an IPv4 address (%s), assume IPv4 operation", nodeIP.String()) - } - var iptInterface utiliptables.Interface var ipvsInterface utilipvs.Interface var kernelHandler ipvs.KernelHandler @@ -119,7 +99,6 @@ func newProxyServer( // Create a iptables utils. execer := exec.New() - iptInterface = utiliptables.New(execer, protocol) kernelHandler = ipvs.NewLinuxKernelHandler() ipsetInterface = utilipset.New(execer) canUseIPVS, err := ipvs.CanUseIPVSProxier(kernelHandler, ipsetInterface) @@ -135,7 +114,6 @@ func newProxyServer( if cleanupAndExit { return &ProxyServer{ execer: execer, - IptInterface: iptInterface, IpvsInterface: ipvsInterface, IpsetInterface: ipsetInterface, }, nil @@ -145,6 +123,27 @@ func newProxyServer( metrics.SetShowHidden() } + hostname, err := utilnode.GetHostname(config.HostnameOverride) + if err != nil { + return nil, err + } + + client, eventClient, err := createClients(config.ClientConnection, master) + if err != nil { + return nil, err + } + + nodeIP := detectNodeIP(client, hostname, config.BindAddress) + protocol := utiliptables.ProtocolIPv4 + if utilsnet.IsIPv6(nodeIP) { + klog.V(0).Infof("kube-proxy node IP is an IPv6 address (%s), assume IPv6 operation", nodeIP.String()) + protocol = utiliptables.ProtocolIPv6 + } else { + klog.V(0).Infof("kube-proxy node IP is an IPv4 address (%s), assume IPv4 operation", nodeIP.String()) + } + + iptInterface = utiliptables.New(execer, protocol) + // Create event recorder eventBroadcaster := record.NewBroadcaster() recorder := eventBroadcaster.NewRecorder(proxyconfigscheme.Scheme, v1.EventSource{Component: "kube-proxy", Host: hostname}) From f9263da533854643c488402b5eca01aaf1f83d46 Mon Sep 17 00:00:00 2001 From: andyzhangx Date: Mon, 9 Nov 2020 04:05:55 +0000 Subject: [PATCH 020/301] fix pull image error from multiple ACRs using azure managed identity fix comments fix comment fix comments fix comments fix comments fix comments fix bazel fix govet --- pkg/credentialprovider/azure/BUILD | 2 + .../azure/azure_credentials.go | 108 ++++++++++++++---- .../azure/azure_credentials_test.go | 14 ++- 3 files changed, 98 insertions(+), 26 deletions(-) diff --git a/pkg/credentialprovider/azure/BUILD b/pkg/credentialprovider/azure/BUILD index 85485c6e26b32..c8c6ac266448b 100644 --- a/pkg/credentialprovider/azure/BUILD +++ b/pkg/credentialprovider/azure/BUILD @@ -16,6 +16,7 @@ go_library( importpath = "k8s.io/kubernetes/pkg/credentialprovider/azure", deps = [ "//pkg/credentialprovider:go_default_library", + "//staging/src/k8s.io/client-go/tools/cache:go_default_library", "//staging/src/k8s.io/legacy-cloud-providers/azure/auth:go_default_library", "//vendor/github.com/Azure/azure-sdk-for-go/services/containerregistry/mgmt/2019-05-01/containerregistry:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest:go_default_library", @@ -32,6 +33,7 @@ go_test( srcs = ["azure_credentials_test.go"], embed = [":go_default_library"], deps = [ + "//staging/src/k8s.io/client-go/tools/cache:go_default_library", "//vendor/github.com/Azure/azure-sdk-for-go/services/containerregistry/mgmt/2019-05-01/containerregistry:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest/azure:go_default_library", "//vendor/github.com/Azure/go-autorest/autorest/to:go_default_library", diff --git a/pkg/credentialprovider/azure/azure_credentials.go b/pkg/credentialprovider/azure/azure_credentials.go index f10288825001e..2d9281482bf29 100644 --- a/pkg/credentialprovider/azure/azure_credentials.go +++ b/pkg/credentialprovider/azure/azure_credentials.go @@ -34,6 +34,7 @@ import ( "github.com/Azure/go-autorest/autorest/azure" "github.com/spf13/pflag" + "k8s.io/client-go/tools/cache" "k8s.io/klog/v2" "k8s.io/kubernetes/pkg/credentialprovider" "k8s.io/legacy-cloud-providers/azure/auth" @@ -56,12 +57,30 @@ var ( // init registers the various means by which credentials may // be resolved on Azure. func init() { - credentialprovider.RegisterCredentialProvider("azure", - &credentialprovider.CachingDockerConfigProvider{ - Provider: NewACRProvider(flagConfigFile), - Lifetime: 1 * time.Minute, - ShouldCache: func(d credentialprovider.DockerConfig) bool { return len(d) > 0 }, - }) + credentialprovider.RegisterCredentialProvider( + "azure", + NewACRProvider(flagConfigFile), + ) +} + +type cacheEntry struct { + expiresAt time.Time + credentials credentialprovider.DockerConfigEntry + registry string +} + +// acrExpirationPolicy implements ExpirationPolicy from client-go. +type acrExpirationPolicy struct{} + +// stringKeyFunc returns the cache key as a string +func stringKeyFunc(obj interface{}) (string, error) { + key := obj.(*cacheEntry).registry + return key, nil +} + +// IsExpired checks if the ACR credentials are expired. +func (p *acrExpirationPolicy) IsExpired(entry *cache.TimestampedEntry) bool { + return time.Now().After(entry.Obj.(*cacheEntry).expiresAt) } // RegistriesClient is a testable interface for the ACR client List operation. @@ -105,7 +124,8 @@ func (az *azRegistriesClient) List(ctx context.Context) ([]containerregistry.Reg // NewACRProvider parses the specified configFile and returns a DockerConfigProvider func NewACRProvider(configFile *string) credentialprovider.DockerConfigProvider { return &acrProvider{ - file: configFile, + file: configFile, + cache: cache.NewExpirationStore(stringKeyFunc, &acrExpirationPolicy{}), } } @@ -115,6 +135,7 @@ type acrProvider struct { environment *azure.Environment registryClient RegistriesClient servicePrincipalToken *adal.ServicePrincipalToken + cache cache.Store } // ParseConfig returns a parsed configuration for an Azure cloudprovider config file @@ -185,25 +206,63 @@ func (a *acrProvider) Enabled() bool { return true } -func (a *acrProvider) Provide(image string) credentialprovider.DockerConfig { - klog.V(4).Infof("try to provide secret for image %s", image) +// getFromCache attempts to get credentials from the cache +func (a *acrProvider) getFromCache(loginServer string) (credentialprovider.DockerConfig, bool) { cfg := credentialprovider.DockerConfig{} + obj, exists, err := a.cache.GetByKey(loginServer) + if err != nil { + klog.Errorf("error getting ACR credentials from cache: %v", err) + return cfg, false + } + if !exists { + return cfg, false + } - defaultConfigEntry := credentialprovider.DockerConfigEntry{ - Username: "", - Password: "", - Email: dummyRegistryEmail, + entry := obj.(*cacheEntry) + cfg[entry.registry] = entry.credentials + return cfg, true +} + +// getFromACR gets credentials from ACR since they are not in the cache +func (a *acrProvider) getFromACR(loginServer string) (credentialprovider.DockerConfig, error) { + cfg := credentialprovider.DockerConfig{} + cred, err := getACRDockerEntryFromARMToken(a, loginServer) + if err != nil { + return cfg, err + } + + entry := &cacheEntry{ + expiresAt: time.Now().Add(10 * time.Minute), + credentials: *cred, + registry: loginServer, + } + if err := a.cache.Add(entry); err != nil { + return cfg, err + } + cfg[loginServer] = *cred + return cfg, nil +} + +func (a *acrProvider) Provide(image string) credentialprovider.DockerConfig { + loginServer := a.parseACRLoginServerFromImage(image) + if loginServer == "" { + klog.V(2).Infof("image(%s) is not from ACR, return empty authentication", image) + return credentialprovider.DockerConfig{} } - if a.config.UseManagedIdentityExtension { - if loginServer := a.parseACRLoginServerFromImage(image); loginServer == "" { - klog.V(4).Infof("image(%s) is not from ACR, skip MSI authentication", image) + cfg := credentialprovider.DockerConfig{} + if a.config != nil && a.config.UseManagedIdentityExtension { + var exists bool + cfg, exists = a.getFromCache(loginServer) + if exists { + klog.V(4).Infof("Got ACR credentials from cache for %s", loginServer) } else { - if cred, err := getACRDockerEntryFromARMToken(a, loginServer); err == nil { - cfg[loginServer] = *cred + klog.V(2).Infof("unable to get ACR credentials from cache for %s, checking ACR API", loginServer) + var err error + cfg, err = a.getFromACR(loginServer) + if err != nil { + klog.Errorf("error getting credentials from ACR for %s %v", loginServer, err) } - // add ACR anonymous repo support: use empty username and password for anonymous access - cfg["*.azurecr.*"] = defaultConfigEntry } } else { // Add our entry for each of the supported container registry URLs @@ -237,10 +296,15 @@ func (a *acrProvider) Provide(image string) credentialprovider.DockerConfig { cfg[customAcrSuffix] = *cred } } + } - // add ACR anonymous repo support: use empty username and password for anonymous access - cfg["*.azurecr.*"] = defaultConfigEntry + // add ACR anonymous repo support: use empty username and password for anonymous access + defaultConfigEntry := credentialprovider.DockerConfigEntry{ + Username: "", + Password: "", + Email: dummyRegistryEmail, } + cfg["*.azurecr.*"] = defaultConfigEntry return cfg } diff --git a/pkg/credentialprovider/azure/azure_credentials_test.go b/pkg/credentialprovider/azure/azure_credentials_test.go index 2cda325ade2d9..edacfc98b5149 100644 --- a/pkg/credentialprovider/azure/azure_credentials_test.go +++ b/pkg/credentialprovider/azure/azure_credentials_test.go @@ -26,6 +26,7 @@ import ( "github.com/Azure/azure-sdk-for-go/services/containerregistry/mgmt/2019-05-01/containerregistry" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/autorest/to" + "k8s.io/client-go/tools/cache" "github.com/stretchr/testify/assert" ) @@ -76,10 +77,11 @@ func Test(t *testing.T) { provider := &acrProvider{ registryClient: fakeClient, + cache: cache.NewExpirationStore(stringKeyFunc, &acrExpirationPolicy{}), } provider.loadConfig(bytes.NewBufferString(configStr)) - creds := provider.Provide("") + creds := provider.Provide("foo.azurecr.io/nginx:v1") if len(creds) != len(result)+1 { t.Errorf("Unexpected list: %v, expected length %d", creds, len(result)+1) @@ -103,11 +105,13 @@ func Test(t *testing.T) { func TestProvide(t *testing.T) { testCases := []struct { desc string + image string configStr string expectedCredsLength int }{ { - desc: "return multiple credentials using Service Principal", + desc: "return multiple credentials using Service Principal", + image: "foo.azurecr.io/bar/image:v1", configStr: ` { "aadClientId": "foo", @@ -116,7 +120,8 @@ func TestProvide(t *testing.T) { expectedCredsLength: 5, }, { - desc: "retuen 0 credential for non-ACR image using Managed Identity", + desc: "retuen 0 credential for non-ACR image using Managed Identity", + image: "busybox", configStr: ` { "UseManagedIdentityExtension": true @@ -128,10 +133,11 @@ func TestProvide(t *testing.T) { for i, test := range testCases { provider := &acrProvider{ registryClient: &fakeClient{}, + cache: cache.NewExpirationStore(stringKeyFunc, &acrExpirationPolicy{}), } provider.loadConfig(bytes.NewBufferString(test.configStr)) - creds := provider.Provide("busybox") + creds := provider.Provide(test.image) assert.Equal(t, test.expectedCredsLength, len(creds), "TestCase[%d]: %s", i, test.desc) } } From f92b61dd5c0f8ab71059d791d38bb4ee154d5e19 Mon Sep 17 00:00:00 2001 From: "Dr. Stefan Schimanski" Date: Fri, 18 Sep 2020 13:44:10 +0200 Subject: [PATCH 021/301] apiextensions: prune array type without items in published OpenAPI kubectl falls over arrays without item schema. Hence, we have to publish a less precise OpenAPI spec (similar to other pruning we already do for the same reason). --- .../pkg/controller/openapi/v2/BUILD | 1 + .../pkg/controller/openapi/v2/conversion.go | 8 +++++ .../controller/openapi/v2/conversion_test.go | 31 +++++++++++++++++++ 3 files changed, 40 insertions(+) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/BUILD index a078e5a337da6..4751762545bb3 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/BUILD @@ -24,6 +24,7 @@ go_test( "//vendor/github.com/googleapis/gnostic/openapiv2:go_default_library", "//vendor/gopkg.in/yaml.v2:go_default_library", "//vendor/k8s.io/kube-openapi/pkg/util/proto:go_default_library", + "//vendor/k8s.io/utils/pointer:go_default_library", ], ) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go index b1d7114bf3ec9..320529bf68d21 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go @@ -73,6 +73,14 @@ func ToStructuralOpenAPIV2(in *structuralschema.Structural) *structuralschema.St changed = true } + if s.Items == nil && s.Type == "array" { + // kubectl cannot cope with array without item schema, e.g. due to XPreserveUnknownFields case above + // https://github.com/kubernetes/kube-openapi/blob/64514a1d5d596b96e6f957e2be275ae14d6b0804/pkg/util/proto/document.go#L185 + s.Type = "" + + changed = true + } + for f, fs := range s.Properties { if fs.Nullable { s.ValueValidation.Required, changed = filterOut(s.ValueValidation.Required, f) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go index 53ca83bb8dd16..eacb92efb98f0 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go @@ -36,6 +36,7 @@ import ( apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema" "k8s.io/kube-openapi/pkg/util/proto" + "k8s.io/utils/pointer" ) func Test_ConvertJSONSchemaPropsToOpenAPIv2Schema(t *testing.T) { @@ -643,6 +644,31 @@ func Test_ConvertJSONSchemaPropsToOpenAPIv2SchemaByType(t *testing.T) { WithExample(testStr), expectDiff: true, }, + { + name: "preserve-unknown-fields in arrays", + in: &apiextensions.JSONSchemaProps{ + XPreserveUnknownFields: pointer.BoolPtr(true), + Type: "array", + Items: &apiextensions.JSONSchemaPropsOrArray{Schema: &apiextensions.JSONSchemaProps{ + Type: "string", + }}, + }, + expected: withVendorExtensions(new(spec.Schema), "x-kubernetes-preserve-unknown-fields", true), + }, + { + name: "preserve-unknown-fields in objects", + in: &apiextensions.JSONSchemaProps{ + XPreserveUnknownFields: pointer.BoolPtr(true), + Type: "object", + Properties: map[string]apiextensions.JSONSchemaProps{ + "foo": { + Type: "string", + }, + }, + }, + expected: withVendorExtensions(new(spec.Schema), "x-kubernetes-preserve-unknown-fields", true). + Typed("object", ""), + }, } for _, test := range tests { @@ -666,6 +692,11 @@ func Test_ConvertJSONSchemaPropsToOpenAPIv2SchemaByType(t *testing.T) { } } +func withVendorExtensions(s *spec.Schema, key string, value interface{}) *spec.Schema { + s.VendorExtensible.AddExtension(key, value) + return s +} + func refEqual(x spec.Ref, y spec.Ref) bool { return x.String() == y.String() } From 798ddefc126c02df983932cbe61d7d005bc29326 Mon Sep 17 00:00:00 2001 From: Gautier Delorme Date: Sat, 7 Nov 2020 17:11:27 +0100 Subject: [PATCH 022/301] prune type in preserve-unknown-fields objects Signed-off-by: Gautier Delorme --- .../pkg/controller/openapi/builder/builder_test.go | 3 +-- .../pkg/controller/openapi/v2/conversion.go | 7 +++++++ .../pkg/controller/openapi/v2/conversion_test.go | 3 +-- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/builder/builder_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/builder/builder_test.go index 78de23af7ecaf..fac53c71b5863 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/builder/builder_test.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/builder/builder_test.go @@ -172,8 +172,7 @@ func TestNewBuilder(t *testing.T) { }, "embedded-object": { "x-kubernetes-embedded-resource": true, - "x-kubernetes-preserve-unknown-fields": true, - "type":"object" + "x-kubernetes-preserve-unknown-fields": true } }, "x-kubernetes-group-version-kind":[{"group":"bar.k8s.io","kind":"Foo","version":"v1"}] diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go index 320529bf68d21..ae5b86a193280 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion.go @@ -81,6 +81,13 @@ func ToStructuralOpenAPIV2(in *structuralschema.Structural) *structuralschema.St changed = true } + if s.XPreserveUnknownFields && s.Type == "object" { + // similar as above, kubectl doesn't properly handle object fields with `x-kubernetes-preserve-unknown-fields: true` + s.Type = "" + + changed = true + } + for f, fs := range s.Properties { if fs.Nullable { s.ValueValidation.Required, changed = filterOut(s.ValueValidation.Required, f) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go index eacb92efb98f0..7a8cb5aabe685 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/controller/openapi/v2/conversion_test.go @@ -666,8 +666,7 @@ func Test_ConvertJSONSchemaPropsToOpenAPIv2SchemaByType(t *testing.T) { }, }, }, - expected: withVendorExtensions(new(spec.Schema), "x-kubernetes-preserve-unknown-fields", true). - Typed("object", ""), + expected: withVendorExtensions(new(spec.Schema), "x-kubernetes-preserve-unknown-fields", true), }, } From 97693571d3d1c765995dcae0009b8cba8f9baed4 Mon Sep 17 00:00:00 2001 From: Gautier Delorme Date: Sat, 7 Nov 2020 20:23:03 +0100 Subject: [PATCH 023/301] update e2e kubectl test Signed-off-by: Gautier Delorme --- test/e2e/apimachinery/crd_publish_openapi.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/e2e/apimachinery/crd_publish_openapi.go b/test/e2e/apimachinery/crd_publish_openapi.go index 1431e5388efb8..a59e088ae99ee 100644 --- a/test/e2e/apimachinery/crd_publish_openapi.go +++ b/test/e2e/apimachinery/crd_publish_openapi.go @@ -230,7 +230,7 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu ns := fmt.Sprintf("--namespace=%v", f.Namespace.Name) ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties") - randomCR := fmt.Sprintf(`{%s,"spec":{"b":[{"c":"d"}]}}`, meta) + randomCR := fmt.Sprintf(`{%s,"spec":{"a":null,"b":[{"c":"d"}]}}`, meta) if _, err := framework.RunKubectlInput(f.Namespace.Name, randomCR, ns, "create", "-f", "-"); err != nil { framework.Failf("failed to create random CR %s for CRD that allows unknown properties in a nested object: %v", randomCR, err) } From 0f4a78bb84380e3ac588ae4e93791a8244338178 Mon Sep 17 00:00:00 2001 From: chenyw1990 Date: Thu, 5 Nov 2020 22:02:41 +0800 Subject: [PATCH 024/301] Fix cacheWatcher leak when time jump to the future and jump back --- .../src/k8s.io/apiserver/pkg/storage/cacher/cacher.go | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go b/staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go index 1b6432b8c366f..1a7197e4dd243 100644 --- a/staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go +++ b/staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.go @@ -158,8 +158,10 @@ func (i *indexedWatchers) terminateAll(objectType reflect.Type, done func(*cache // second in a bucket, and pop up them once at the timeout. To be more specific, // if you set fire time at X, you can get the bookmark within (X-1,X+1) period. type watcherBookmarkTimeBuckets struct { - lock sync.Mutex + lock sync.Mutex + // the key of watcherBuckets is the number of seconds since createTime watchersBuckets map[int64][]*cacheWatcher + createTime time.Time startBucketID int64 clock clock.Clock bookmarkFrequency time.Duration @@ -168,7 +170,8 @@ type watcherBookmarkTimeBuckets struct { func newTimeBucketWatchers(clock clock.Clock, bookmarkFrequency time.Duration) *watcherBookmarkTimeBuckets { return &watcherBookmarkTimeBuckets{ watchersBuckets: make(map[int64][]*cacheWatcher), - startBucketID: clock.Now().Unix(), + createTime: clock.Now(), + startBucketID: 0, clock: clock, bookmarkFrequency: bookmarkFrequency, } @@ -181,7 +184,7 @@ func (t *watcherBookmarkTimeBuckets) addWatcher(w *cacheWatcher) bool { if !ok { return false } - bucketID := nextTime.Unix() + bucketID := int64(nextTime.Sub(t.createTime) / time.Second) t.lock.Lock() defer t.lock.Unlock() if bucketID < t.startBucketID { @@ -193,7 +196,7 @@ func (t *watcherBookmarkTimeBuckets) addWatcher(w *cacheWatcher) bool { } func (t *watcherBookmarkTimeBuckets) popExpiredWatchers() [][]*cacheWatcher { - currentBucketID := t.clock.Now().Unix() + currentBucketID := int64(t.clock.Since(t.createTime) / time.Second) // There should be one or two elements in almost all cases expiredWatchers := make([][]*cacheWatcher, 0, 2) t.lock.Lock() From bb08d4865017e01c3d2eb5bece68a3ac854cf574 Mon Sep 17 00:00:00 2001 From: ruiwen-zhao Date: Wed, 18 Nov 2020 22:39:01 +0000 Subject: [PATCH 025/301] Updating to cadvisor v0.37.1 --- go.mod | 4 ++-- go.sum | 4 ++-- vendor/github.com/google/cadvisor/accelerators/nvidia.go | 4 +--- vendor/modules.txt | 4 ++-- 4 files changed, 7 insertions(+), 9 deletions(-) diff --git a/go.mod b/go.mod index 9c19156545b56..82e23052a05e1 100644 --- a/go.mod +++ b/go.mod @@ -53,7 +53,7 @@ require ( github.com/gogo/protobuf v1.3.1 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7 github.com/golang/mock v1.3.1 - github.com/google/cadvisor v0.37.0 + github.com/google/cadvisor v0.37.1 github.com/google/go-cmp v0.4.0 github.com/google/gofuzz v1.1.0 github.com/google/uuid v1.1.1 @@ -274,7 +274,7 @@ replace ( github.com/golangplus/fmt => github.com/golangplus/fmt v0.0.0-20150411045040-2a5d6d7d2995 github.com/golangplus/testing => github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e github.com/google/btree => github.com/google/btree v1.0.0 - github.com/google/cadvisor => github.com/google/cadvisor v0.37.0 + github.com/google/cadvisor => github.com/google/cadvisor v0.37.1 github.com/google/go-cmp => github.com/google/go-cmp v0.4.0 github.com/google/gofuzz => github.com/google/gofuzz v1.1.0 github.com/google/martian => github.com/google/martian v2.1.0+incompatible diff --git a/go.sum b/go.sum index 1e1eed65a9c55..722d78a685f16 100644 --- a/go.sum +++ b/go.sum @@ -223,8 +223,8 @@ github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e h1:KhcknUwkWHKZ github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e/go.mod h1:0AA//k/eakGydO4jKRoRL2j92ZKSzTgj9tclaCrvXHk= github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/cadvisor v0.37.0 h1:t3txV4zNZZGTuwuA/Onm3HToPhg16GjigAHZHEVIz+c= -github.com/google/cadvisor v0.37.0/go.mod h1:OhDE+goNVel0eGY8mR7Ifq1QUI1in5vJBIgIpcajK/I= +github.com/google/cadvisor v0.37.1 h1:P5KDKzZurwXlltf5jqnC8YFKv+JgBtltFEPvlfOJcnU= +github.com/google/cadvisor v0.37.1/go.mod h1:OhDE+goNVel0eGY8mR7Ifq1QUI1in5vJBIgIpcajK/I= github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g= diff --git a/vendor/github.com/google/cadvisor/accelerators/nvidia.go b/vendor/github.com/google/cadvisor/accelerators/nvidia.go index 08d5108f3876e..1c51b5deaed2e 100644 --- a/vendor/github.com/google/cadvisor/accelerators/nvidia.go +++ b/vendor/github.com/google/cadvisor/accelerators/nvidia.go @@ -58,9 +58,7 @@ func NewNvidiaManager(includedMetrics container.MetricSet) stats.Manager { manager := &nvidiaManager{} err := manager.setup() if err != nil { - klog.Warningf("NVIDIA GPU metrics will not be available: %s", err) - manager.Destroy() - return &stats.NoopManager{} + klog.V(2).Infof("NVIDIA setup failed: %s", err) } return manager } diff --git a/vendor/modules.txt b/vendor/modules.txt index 397f97d5f5ea4..ec65b68386979 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -507,9 +507,9 @@ github.com/golang/protobuf/ptypes/wrappers # github.com/google/btree v1.0.0 => github.com/google/btree v1.0.0 github.com/google/btree # github.com/google/btree => github.com/google/btree v1.0.0 -# github.com/google/cadvisor v0.37.0 => github.com/google/cadvisor v0.37.0 +# github.com/google/cadvisor v0.37.1 => github.com/google/cadvisor v0.37.1 ## explicit -# github.com/google/cadvisor => github.com/google/cadvisor v0.37.0 +# github.com/google/cadvisor => github.com/google/cadvisor v0.37.1 github.com/google/cadvisor/accelerators github.com/google/cadvisor/cache/memory github.com/google/cadvisor/client/v2 From 7ef08a851131746a3ec8f6b2596d06bb7c314c9c Mon Sep 17 00:00:00 2001 From: Jing Xu Date: Wed, 21 Oct 2020 12:13:46 -0700 Subject: [PATCH 026/301] Remove ready directory which created in empty volumeMounter setUp func Change-Id: I2384b07c7a044149e93e951a45f9f8a7bd9dba15 --- pkg/volume/emptydir/empty_dir.go | 20 ++++- pkg/volume/emptydir/empty_dir_test.go | 112 +++++++++++++++++++------- 2 files changed, 99 insertions(+), 33 deletions(-) diff --git a/pkg/volume/emptydir/empty_dir.go b/pkg/volume/emptydir/empty_dir.go index 07384cc9e0591..d9a1704623e1f 100644 --- a/pkg/volume/emptydir/empty_dir.go +++ b/pkg/volume/emptydir/empty_dir.go @@ -208,11 +208,21 @@ func (ed *emptyDir) SetUpAt(dir string, mounterArgs volume.MounterArgs) error { // storage medium is the default, then the volume is ready. If the // medium is memory, and a mountpoint is present, then the volume is // ready. - if volumeutil.IsReady(ed.getMetaDir()) { + readyDir := ed.getMetaDir() + if volumeutil.IsReady(readyDir) { if ed.medium == v1.StorageMediumMemory && !notMnt { return nil } else if ed.medium == v1.StorageMediumDefault { - return nil + // Further check dir exists + if _, err := os.Stat(dir); err == nil { + return nil + } + // This situation should not happen unless user manually delete volume dir. + // In this case, delete ready file and print a warning for it. + klog.Warningf("volume ready file dir %s exist, but volume dir %s does not. Remove ready dir", readyDir, dir) + if err := os.RemoveAll(readyDir); err != nil && !os.IsNotExist(err) { + klog.Warningf("failed to remove ready dir [%s]: %v", readyDir, err) + } } } @@ -421,6 +431,12 @@ func (ed *emptyDir) TearDown() error { // TearDownAt simply discards everything in the directory. func (ed *emptyDir) TearDownAt(dir string) error { + // First remove ready dir which created in SetUp func + readyDir := ed.getMetaDir() + if removeErr := os.RemoveAll(readyDir); removeErr != nil && !os.IsNotExist(removeErr) { + return fmt.Errorf("failed to remove ready dir [%s]: %v", readyDir, removeErr) + } + if pathExists, pathErr := mount.PathExists(dir); pathErr != nil { return fmt.Errorf("Error checking if path exists: %v", pathErr) } else if !pathExists { diff --git a/pkg/volume/emptydir/empty_dir_test.go b/pkg/volume/emptydir/empty_dir_test.go index 78663ac29388f..550d34553fbff 100644 --- a/pkg/volume/emptydir/empty_dir_test.go +++ b/pkg/volume/emptydir/empty_dir_test.go @@ -25,7 +25,7 @@ import ( "path/filepath" "testing" - "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" @@ -36,6 +36,7 @@ import ( "k8s.io/kubernetes/pkg/volume" volumetest "k8s.io/kubernetes/pkg/volume/testing" "k8s.io/kubernetes/pkg/volume/util" + volumeutil "k8s.io/kubernetes/pkg/volume/util" "k8s.io/utils/mount" ) @@ -81,6 +82,26 @@ func (fake *fakeMountDetector) GetMountMedium(path string, requestedMedium v1.St func TestPluginEmptyRootContext(t *testing.T) { doTestPlugin(t, pluginTestConfig{ + volumeDirExists: true, + readyDirExists: true, + medium: v1.StorageMediumDefault, + expectedSetupMounts: 0, + expectedTeardownMounts: 0}) + doTestPlugin(t, pluginTestConfig{ + volumeDirExists: false, + readyDirExists: false, + medium: v1.StorageMediumDefault, + expectedSetupMounts: 0, + expectedTeardownMounts: 0}) + doTestPlugin(t, pluginTestConfig{ + volumeDirExists: true, + readyDirExists: false, + medium: v1.StorageMediumDefault, + expectedSetupMounts: 0, + expectedTeardownMounts: 0}) + doTestPlugin(t, pluginTestConfig{ + volumeDirExists: false, + readyDirExists: true, medium: v1.StorageMediumDefault, expectedSetupMounts: 0, expectedTeardownMounts: 0}) @@ -117,8 +138,11 @@ func TestPluginHugetlbfs(t *testing.T) { } type pluginTestConfig struct { - medium v1.StorageMedium - idempotent bool + medium v1.StorageMedium + //volumeDirExists indicates whether volumeDir already/still exists before volume setup/teardown + volumeDirExists bool + //readyDirExists indicates whether readyDir already/still exists before volume setup/teardown + readyDirExists bool expectedSetupMounts int shouldBeMountedBeforeTeardown bool expectedTeardownMounts int @@ -163,7 +187,7 @@ func doTestPlugin(t *testing.T, config pluginTestConfig) { } ) - if config.idempotent { + if config.readyDirExists { physicalMounter.MountPoints = []mount.MountPoint{ { Path: volumePath, @@ -188,29 +212,14 @@ func doTestPlugin(t *testing.T, config pluginTestConfig) { if volPath != volumePath { t.Errorf("Got unexpected path: %s", volPath) } - - if err := mounter.SetUp(volume.MounterArgs{}); err != nil { - t.Errorf("Expected success, got: %v", err) + if config.volumeDirExists { + if err := os.MkdirAll(volPath, perm); err != nil { + t.Errorf("fail to create path: %s", volPath) + } } // Stat the directory and check the permission bits - fileinfo, err := os.Stat(volPath) - if !config.idempotent { - if err != nil { - if os.IsNotExist(err) { - t.Errorf("SetUp() failed, volume path not created: %s", volPath) - } else { - t.Errorf("SetUp() failed: %v", err) - } - } - if e, a := perm, fileinfo.Mode().Perm(); e != a { - t.Errorf("Unexpected file mode for %v: expected: %v, got: %v", volPath, e, a) - } - } else if err == nil { - // If this test is for idempotency and we were able - // to stat the volume path, it's an error. - t.Errorf("Volume directory was created unexpectedly") - } + testSetUp(mounter, metadataDir, volPath) log := physicalMounter.GetLog() // Check the number of mounts performed during setup @@ -236,14 +245,19 @@ func doTestPlugin(t *testing.T, config pluginTestConfig) { t.Errorf("Got a nil Unmounter") } - // Tear down the volume - if err := unmounter.TearDown(); err != nil { - t.Errorf("Expected success, got: %v", err) + if !config.readyDirExists { + if err := os.RemoveAll(metadataDir); err != nil && !os.IsNotExist(err) { + t.Errorf("failed to remove ready dir [%s]: %v", metadataDir, err) + } } - if _, err := os.Stat(volPath); err == nil { - t.Errorf("TearDown() failed, volume path still exists: %s", volPath) - } else if !os.IsNotExist(err) { - t.Errorf("TearDown() failed: %v", err) + if !config.volumeDirExists { + if err := os.RemoveAll(volPath); err != nil && !os.IsNotExist(err) { + t.Errorf("failed to remove ready dir [%s]: %v", metadataDir, err) + } + } + // Tear down the volume + if err := testTearDown(unmounter, metadataDir, volPath); err != nil { + t.Errorf("Test failed with error %v", err) } log = physicalMounter.GetLog() @@ -256,6 +270,42 @@ func doTestPlugin(t *testing.T, config pluginTestConfig) { physicalMounter.ResetLog() } +func testSetUp(mounter volume.Mounter, metadataDir, volPath string) error { + if err := mounter.SetUp(volume.MounterArgs{}); err != nil { + return fmt.Errorf("Expected success, got: %v", err) + } + // Stat the directory and check the permission bits + if !volumeutil.IsReady(metadataDir) { + return fmt.Errorf("SetUp() failed, ready file is not created") + } + fileinfo, err := os.Stat(volPath) + if err != nil { + if os.IsNotExist(err) { + return fmt.Errorf("SetUp() failed, volume path not created: %s", volPath) + } + return fmt.Errorf("SetUp() failed: %v", err) + } + if e, a := perm, fileinfo.Mode().Perm(); e != a { + return fmt.Errorf("Unexpected file mode for %v: expected: %v, got: %v", volPath, e, a) + } + return nil +} + +func testTearDown(unmounter volume.Unmounter, metadataDir, volPath string) error { + if err := unmounter.TearDown(); err != nil { + return err + } + if volumeutil.IsReady(metadataDir) { + return fmt.Errorf("Teardown() failed, ready file still exists") + } + if _, err := os.Stat(volPath); err == nil { + return fmt.Errorf("TearDown() failed, volume path still exists: %s", volPath) + } else if !os.IsNotExist(err) { + return fmt.Errorf("TearDown() failed: %v", err) + } + return nil +} + func TestPluginBackCompat(t *testing.T) { basePath, err := utiltesting.MkTmpdir("emptydirTest") if err != nil { From f3fe4247a32cb86388db6b9a443ca816f2f58238 Mon Sep 17 00:00:00 2001 From: andyzhangx Date: Thu, 19 Nov 2020 07:25:11 +0000 Subject: [PATCH 027/301] fix: resize Azure disk issue when it's in attached state fix comments --- .../azure/azure_managedDiskController.go | 4 ++++ .../azure/azure_managedDiskController_test.go | 18 ++++++++++++++---- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController.go b/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController.go index 6189519998b35..6969ba0b34f8f 100644 --- a/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController.go +++ b/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController.go @@ -297,6 +297,10 @@ func (c *ManagedDiskController) ResizeDisk(diskURI string, oldSize resource.Quan return newSizeQuant, nil } + if result.DiskProperties.DiskState != compute.Unattached { + return oldSize, fmt.Errorf("azureDisk - disk resize is only supported on Unattached disk, current disk state: %s, already attached to %s", result.DiskProperties.DiskState, to.String(result.ManagedBy)) + } + diskParameter := compute.DiskUpdate{ DiskUpdateProperties: &compute.DiskUpdateProperties{ DiskSizeGB: &requestGiB, diff --git a/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController_test.go b/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController_test.go index 99e38496d814f..e36178258810c 100644 --- a/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController_test.go +++ b/staging/src/k8s.io/legacy-cloud-providers/azure/azure_managedDiskController_test.go @@ -311,7 +311,7 @@ func TestResizeDisk(t *testing.T) { diskName: diskName, oldSize: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), newSize: *resource.NewQuantity(3*(1024*1024*1024), resource.BinarySI), - existedDisk: compute.Disk{Name: to.StringPtr("disk1"), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB}}, + existedDisk: compute.Disk{Name: to.StringPtr("disk1"), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB, DiskState: compute.Unattached}}, expectedQuantity: *resource.NewQuantity(3*(1024*1024*1024), resource.BinarySI), expectedErr: false, }, @@ -330,7 +330,7 @@ func TestResizeDisk(t *testing.T) { diskName: diskName, oldSize: *resource.NewQuantity(1*(1024*1024*1024), resource.BinarySI), newSize: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), - existedDisk: compute.Disk{Name: to.StringPtr("disk1"), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB}}, + existedDisk: compute.Disk{Name: to.StringPtr("disk1"), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB, DiskState: compute.Unattached}}, expectedQuantity: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), expectedErr: false, }, @@ -339,7 +339,7 @@ func TestResizeDisk(t *testing.T) { diskName: fakeGetDiskFailed, oldSize: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), newSize: *resource.NewQuantity(3*(1024*1024*1024), resource.BinarySI), - existedDisk: compute.Disk{Name: to.StringPtr(fakeGetDiskFailed), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB}}, + existedDisk: compute.Disk{Name: to.StringPtr(fakeGetDiskFailed), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB, DiskState: compute.Unattached}}, expectedQuantity: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), expectedErr: true, expectedErrMsg: fmt.Errorf("Retriable: false, RetryAfter: 0s, HTTPStatusCode: 0, RawError: Get Disk failed"), @@ -349,11 +349,21 @@ func TestResizeDisk(t *testing.T) { diskName: fakeCreateDiskFailed, oldSize: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), newSize: *resource.NewQuantity(3*(1024*1024*1024), resource.BinarySI), - existedDisk: compute.Disk{Name: to.StringPtr(fakeCreateDiskFailed), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB}}, + existedDisk: compute.Disk{Name: to.StringPtr(fakeCreateDiskFailed), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB, DiskState: compute.Unattached}}, expectedQuantity: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), expectedErr: true, expectedErrMsg: fmt.Errorf("Retriable: false, RetryAfter: 0s, HTTPStatusCode: 0, RawError: Create Disk failed"), }, + { + desc: "an error shall be returned if disk is not in Unattached state", + diskName: fakeCreateDiskFailed, + oldSize: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), + newSize: *resource.NewQuantity(3*(1024*1024*1024), resource.BinarySI), + existedDisk: compute.Disk{Name: to.StringPtr(fakeCreateDiskFailed), DiskProperties: &compute.DiskProperties{DiskSizeGB: &diskSizeGB, DiskState: compute.Attached}}, + expectedQuantity: *resource.NewQuantity(2*(1024*1024*1024), resource.BinarySI), + expectedErr: true, + expectedErrMsg: fmt.Errorf("azureDisk - disk resize is only supported on Unattached disk, current disk state: Attached, already attached to "), + }, } for i, test := range testCases { From 5201ec00ac2535c9583d1fae131d28b33826db31 Mon Sep 17 00:00:00 2001 From: Chao Xu Date: Sat, 21 Nov 2020 05:19:42 +0000 Subject: [PATCH 028/301] update golang.org/x/net and golang.org/x/sys, equivalent of #96549 --- go.mod | 8 +- go.sum | 8 +- staging/src/k8s.io/api/go.sum | 7 +- .../src/k8s.io/apiextensions-apiserver/go.sum | 9 +- staging/src/k8s.io/apimachinery/go.mod | 5 +- staging/src/k8s.io/apimachinery/go.sum | 9 +- staging/src/k8s.io/apiserver/go.mod | 4 +- staging/src/k8s.io/apiserver/go.sum | 9 +- staging/src/k8s.io/cli-runtime/go.sum | 9 +- staging/src/k8s.io/client-go/go.mod | 2 +- staging/src/k8s.io/client-go/go.sum | 9 +- staging/src/k8s.io/cloud-provider/go.sum | 9 +- staging/src/k8s.io/cluster-bootstrap/go.sum | 7 +- staging/src/k8s.io/code-generator/go.mod | 3 +- staging/src/k8s.io/code-generator/go.sum | 5 +- staging/src/k8s.io/component-base/go.sum | 9 +- staging/src/k8s.io/cri-api/go.mod | 5 +- staging/src/k8s.io/cri-api/go.sum | 10 +- staging/src/k8s.io/csi-translation-lib/go.sum | 7 +- staging/src/k8s.io/kube-aggregator/go.mod | 2 +- staging/src/k8s.io/kube-aggregator/go.sum | 9 +- .../src/k8s.io/kube-controller-manager/go.sum | 7 +- staging/src/k8s.io/kube-proxy/go.sum | 7 +- staging/src/k8s.io/kube-scheduler/go.sum | 7 +- staging/src/k8s.io/kubectl/go.mod | 2 +- staging/src/k8s.io/kubectl/go.sum | 9 +- staging/src/k8s.io/kubelet/go.mod | 2 +- staging/src/k8s.io/kubelet/go.sum | 9 +- .../src/k8s.io/legacy-cloud-providers/go.sum | 9 +- staging/src/k8s.io/metrics/go.sum | 9 +- staging/src/k8s.io/sample-apiserver/go.sum | 9 +- staging/src/k8s.io/sample-cli-plugin/go.sum | 9 +- staging/src/k8s.io/sample-controller/go.sum | 9 +- vendor/golang.org/x/net/html/const.go | 2 +- vendor/golang.org/x/net/html/foreign.go | 119 +- vendor/golang.org/x/net/html/parse.go | 15 +- vendor/golang.org/x/net/html/render.go | 2 +- vendor/golang.org/x/net/http2/server.go | 12 +- vendor/golang.org/x/net/http2/transport.go | 36 +- vendor/golang.org/x/net/idna/BUILD | 3 +- .../idna/{tables12.00.go => tables12.0.0.go} | 2 +- vendor/golang.org/x/net/idna/tables13.0.0.go | 4839 +++++++++++++++++ vendor/golang.org/x/net/internal/socket/BUILD | 9 +- .../x/net/internal/socket/cmsghdr.go | 2 +- .../x/net/internal/socket/cmsghdr_stub.go | 16 +- .../x/net/internal/socket/cmsghdr_unix.go | 21 + .../net/internal/socket/cmsghdr_zos_s390x.go | 25 + .../x/net/internal/socket/error_unix.go | 2 +- .../x/net/internal/socket/iovec_64bit.go | 2 +- .../x/net/internal/socket/iovec_stub.go | 2 +- .../x/net/internal/socket/msghdr_stub.go | 2 +- .../x/net/internal/socket/msghdr_zos_s390x.go | 36 + .../x/net/internal/socket/rawconn_msg.go | 7 +- .../x/net/internal/socket/rawconn_nomsg.go | 2 +- .../x/net/internal/socket/socket.go | 10 +- .../golang.org/x/net/internal/socket/sys.go | 14 +- .../x/net/internal/socket/sys_bsdvar.go | 23 - .../x/net/internal/socket/sys_const_zos.go | 17 + .../x/net/internal/socket/sys_darwin.go | 7 - .../x/net/internal/socket/sys_dragonfly.go | 32 - .../x/net/internal/socket/sys_linux.go | 5 - .../x/net/internal/socket/sys_linux_386.go | 2 - .../x/net/internal/socket/sys_linux_s390x.go | 2 - .../x/net/internal/socket/sys_posix.go | 2 +- .../x/net/internal/socket/sys_solaris.go | 11 - .../x/net/internal/socket/sys_stub.go | 18 +- ...{sys_go1_11_darwin.go => sys_zos_s390x.go} | 19 +- .../x/net/internal/socket/sys_zos_s390x.s | 11 + .../x/net/internal/socket/zsys_aix_ppc64.go | 5 +- .../x/net/internal/socket/zsys_darwin_386.go | 5 +- .../net/internal/socket/zsys_darwin_amd64.go | 5 +- .../x/net/internal/socket/zsys_darwin_arm.go | 5 +- .../net/internal/socket/zsys_darwin_arm64.go | 5 +- .../internal/socket/zsys_dragonfly_amd64.go | 5 +- .../x/net/internal/socket/zsys_freebsd_386.go | 5 +- .../net/internal/socket/zsys_freebsd_amd64.go | 5 +- .../x/net/internal/socket/zsys_freebsd_arm.go | 5 +- .../net/internal/socket/zsys_freebsd_arm64.go | 5 +- .../x/net/internal/socket/zsys_linux_386.go | 5 +- .../x/net/internal/socket/zsys_linux_amd64.go | 5 +- .../x/net/internal/socket/zsys_linux_arm.go | 2 - .../x/net/internal/socket/zsys_linux_arm64.go | 2 - .../x/net/internal/socket/zsys_linux_mips.go | 2 - .../net/internal/socket/zsys_linux_mips64.go | 2 - .../internal/socket/zsys_linux_mips64le.go | 2 - .../net/internal/socket/zsys_linux_mipsle.go | 2 - .../x/net/internal/socket/zsys_linux_ppc64.go | 2 - .../net/internal/socket/zsys_linux_ppc64le.go | 2 - .../net/internal/socket/zsys_linux_riscv64.go | 2 - .../x/net/internal/socket/zsys_linux_s390x.go | 2 - .../x/net/internal/socket/zsys_netbsd_386.go | 2 - .../net/internal/socket/zsys_netbsd_amd64.go | 2 - .../x/net/internal/socket/zsys_netbsd_arm.go | 2 - .../net/internal/socket/zsys_netbsd_arm64.go | 5 +- .../x/net/internal/socket/zsys_openbsd_386.go | 5 +- .../net/internal/socket/zsys_openbsd_amd64.go | 5 +- .../x/net/internal/socket/zsys_openbsd_arm.go | 5 +- .../net/internal/socket/zsys_openbsd_arm64.go | 5 +- .../net/internal/socket/zsys_solaris_amd64.go | 5 +- .../x/net/internal/socket/zsys_zos_s390x.go | 32 + vendor/golang.org/x/net/ipv4/BUILD | 3 + vendor/golang.org/x/net/ipv4/control_stub.go | 2 +- vendor/golang.org/x/net/ipv4/control_zos.go | 86 + vendor/golang.org/x/net/ipv4/header.go | 4 +- vendor/golang.org/x/net/ipv4/payload_cmsg.go | 2 +- .../golang.org/x/net/ipv4/payload_nocmsg.go | 2 +- vendor/golang.org/x/net/ipv4/sockopt_posix.go | 2 +- vendor/golang.org/x/net/ipv4/sockopt_stub.go | 2 +- vendor/golang.org/x/net/ipv4/sys_stub.go | 2 +- vendor/golang.org/x/net/ipv4/sys_zos.go | 55 + .../golang.org/x/net/ipv4/zsys_zos_s390x.go | 80 + vendor/golang.org/x/net/ipv6/BUILD | 3 + .../x/net/ipv6/control_rfc3542_unix.go | 2 +- vendor/golang.org/x/net/ipv6/control_stub.go | 2 +- vendor/golang.org/x/net/ipv6/control_unix.go | 2 +- vendor/golang.org/x/net/ipv6/icmp_stub.go | 2 +- vendor/golang.org/x/net/ipv6/icmp_zos.go | 29 + vendor/golang.org/x/net/ipv6/payload_cmsg.go | 2 +- .../golang.org/x/net/ipv6/payload_nocmsg.go | 2 +- vendor/golang.org/x/net/ipv6/sockopt_posix.go | 2 +- vendor/golang.org/x/net/ipv6/sockopt_stub.go | 2 +- vendor/golang.org/x/net/ipv6/sys_ssmreq.go | 2 +- .../golang.org/x/net/ipv6/sys_ssmreq_stub.go | 2 +- vendor/golang.org/x/net/ipv6/sys_stub.go | 2 +- vendor/golang.org/x/net/ipv6/sys_zos.go | 70 + .../golang.org/x/net/ipv6/zsys_zos_s390x.go | 106 + vendor/golang.org/x/sys/cpu/BUILD | 6 + vendor/golang.org/x/sys/cpu/cpu.go | 156 +- vendor/golang.org/x/sys/cpu/cpu_aix.go | 4 +- vendor/golang.org/x/sys/cpu/cpu_arm.go | 33 + vendor/golang.org/x/sys/cpu/cpu_arm64.go | 70 +- vendor/golang.org/x/sys/cpu/cpu_linux.go | 2 +- .../golang.org/x/sys/cpu/cpu_linux_mips64x.go | 1 + .../golang.org/x/sys/cpu/cpu_linux_ppc64x.go | 2 - .../golang.org/x/sys/cpu/cpu_linux_s390x.go | 123 +- vendor/golang.org/x/sys/cpu/cpu_mips64x.go | 6 + vendor/golang.org/x/sys/cpu/cpu_mipsx.go | 2 + .../golang.org/x/sys/cpu/cpu_netbsd_arm64.go | 173 + vendor/golang.org/x/sys/cpu/cpu_other_arm.go | 9 + .../golang.org/x/sys/cpu/cpu_other_arm64.go | 3 +- .../golang.org/x/sys/cpu/cpu_other_mips64x.go | 12 + vendor/golang.org/x/sys/cpu/cpu_ppc64x.go | 16 + vendor/golang.org/x/sys/cpu/cpu_riscv64.go | 2 + vendor/golang.org/x/sys/cpu/cpu_s390x.go | 172 + vendor/golang.org/x/sys/cpu/cpu_wasm.go | 4 + vendor/golang.org/x/sys/cpu/cpu_x86.go | 82 +- vendor/golang.org/x/sys/cpu/cpu_zos.go | 10 + vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go | 25 + vendor/golang.org/x/sys/unix/BUILD | 9 +- .../x/sys/unix/asm_openbsd_mips64.s | 29 + vendor/golang.org/x/sys/unix/fcntl_darwin.go | 6 + .../x/sys/unix/fcntl_linux_32bit.go | 4 +- vendor/golang.org/x/sys/unix/gccgo.go | 2 - vendor/golang.org/x/sys/unix/gccgo_c.c | 6 + vendor/golang.org/x/sys/unix/ioctl.go | 9 + vendor/golang.org/x/sys/unix/mkall.sh | 15 +- vendor/golang.org/x/sys/unix/mkerrors.sh | 24 +- .../x/sys/unix/sockcmsg_unix_other.go | 6 +- vendor/golang.org/x/sys/unix/syscall.go | 43 +- vendor/golang.org/x/sys/unix/syscall_aix.go | 16 + vendor/golang.org/x/sys/unix/syscall_bsd.go | 36 +- .../x/sys/unix/syscall_darwin.1_12.go | 4 +- .../golang.org/x/sys/unix/syscall_darwin.go | 141 +- .../x/sys/unix/syscall_darwin_386.1_11.go | 9 - .../x/sys/unix/syscall_darwin_386.go | 11 +- .../x/sys/unix/syscall_darwin_amd64.1_11.go | 9 - .../x/sys/unix/syscall_darwin_amd64.go | 11 +- .../x/sys/unix/syscall_darwin_arm.1_11.go | 11 - .../x/sys/unix/syscall_darwin_arm.go | 8 +- .../x/sys/unix/syscall_darwin_arm64.1_11.go | 11 - .../x/sys/unix/syscall_darwin_arm64.go | 13 +- .../x/sys/unix/syscall_dragonfly.go | 19 +- .../golang.org/x/sys/unix/syscall_freebsd.go | 19 +- .../golang.org/x/sys/unix/syscall_illumos.go | 41 +- vendor/golang.org/x/sys/unix/syscall_linux.go | 142 +- .../x/sys/unix/syscall_linux_386.go | 3 - .../x/sys/unix/syscall_linux_arm.go | 5 - .../x/sys/unix/syscall_linux_gc_arm.go | 13 + .../golang.org/x/sys/unix/syscall_netbsd.go | 19 +- .../golang.org/x/sys/unix/syscall_openbsd.go | 19 +- .../x/sys/unix/syscall_openbsd_mips64.go | 35 + .../golang.org/x/sys/unix/syscall_solaris.go | 7 +- .../x/sys/unix/zerrors_darwin_386.go | 4 + .../x/sys/unix/zerrors_darwin_amd64.go | 4 + .../x/sys/unix/zerrors_darwin_arm.go | 4 + .../x/sys/unix/zerrors_darwin_arm64.go | 4 + .../x/sys/unix/zerrors_dragonfly_amd64.go | 138 +- .../x/sys/unix/zerrors_freebsd_386.go | 6 + .../x/sys/unix/zerrors_freebsd_amd64.go | 6 + .../x/sys/unix/zerrors_freebsd_arm.go | 6 + .../x/sys/unix/zerrors_freebsd_arm64.go | 6 + vendor/golang.org/x/sys/unix/zerrors_linux.go | 236 +- .../x/sys/unix/zerrors_linux_386.go | 3 + .../x/sys/unix/zerrors_linux_amd64.go | 3 + .../x/sys/unix/zerrors_linux_arm.go | 3 + .../x/sys/unix/zerrors_linux_arm64.go | 4 + .../x/sys/unix/zerrors_linux_mips.go | 3 + .../x/sys/unix/zerrors_linux_mips64.go | 3 + .../x/sys/unix/zerrors_linux_mips64le.go | 3 + .../x/sys/unix/zerrors_linux_mipsle.go | 3 + .../x/sys/unix/zerrors_linux_ppc64.go | 3 + .../x/sys/unix/zerrors_linux_ppc64le.go | 3 + .../x/sys/unix/zerrors_linux_riscv64.go | 3 + .../x/sys/unix/zerrors_linux_s390x.go | 3 + .../x/sys/unix/zerrors_linux_sparc64.go | 3 + .../x/sys/unix/zerrors_netbsd_386.go | 6 + .../x/sys/unix/zerrors_netbsd_amd64.go | 6 + .../x/sys/unix/zerrors_netbsd_arm.go | 6 + .../x/sys/unix/zerrors_netbsd_arm64.go | 6 + .../x/sys/unix/zerrors_openbsd_386.go | 7 + .../x/sys/unix/zerrors_openbsd_amd64.go | 7 + .../x/sys/unix/zerrors_openbsd_arm.go | 7 + .../x/sys/unix/zerrors_openbsd_arm64.go | 7 + .../x/sys/unix/zerrors_openbsd_mips64.go | 1862 +++++++ .../x/sys/unix/zerrors_solaris_amd64.go | 22 +- .../x/sys/unix/zsyscall_darwin_386.1_11.go | 1809 ------ .../x/sys/unix/zsyscall_darwin_386.go | 137 +- .../x/sys/unix/zsyscall_darwin_386.s | 18 +- .../x/sys/unix/zsyscall_darwin_amd64.1_11.go | 1809 ------ .../x/sys/unix/zsyscall_darwin_amd64.go | 137 +- .../x/sys/unix/zsyscall_darwin_amd64.s | 18 +- .../x/sys/unix/zsyscall_darwin_arm.1_11.go | 1782 ------ .../x/sys/unix/zsyscall_darwin_arm.go | 107 +- .../x/sys/unix/zsyscall_darwin_arm.s | 14 +- .../x/sys/unix/zsyscall_darwin_arm64.go | 122 +- .../x/sys/unix/zsyscall_darwin_arm64.s | 16 +- .../x/sys/unix/zsyscall_dragonfly_amd64.go | 32 +- .../x/sys/unix/zsyscall_illumos_amd64.go | 29 +- .../golang.org/x/sys/unix/zsyscall_linux.go | 77 + ...m64.1_11.go => zsyscall_openbsd_mips64.go} | 496 +- .../x/sys/unix/zsysctl_openbsd_mips64.go | 279 + .../x/sys/unix/zsysnum_darwin_386.go | 1 + .../x/sys/unix/zsysnum_darwin_amd64.go | 1 + .../x/sys/unix/zsysnum_darwin_arm.go | 1 + .../x/sys/unix/zsysnum_darwin_arm64.go | 1 + .../x/sys/unix/zsysnum_dragonfly_amd64.go | 255 +- .../x/sys/unix/zsysnum_linux_386.go | 2 + .../x/sys/unix/zsysnum_linux_amd64.go | 2 + .../x/sys/unix/zsysnum_linux_arm.go | 2 + .../x/sys/unix/zsysnum_linux_arm64.go | 2 + .../x/sys/unix/zsysnum_linux_mips.go | 2 + .../x/sys/unix/zsysnum_linux_mips64.go | 2 + .../x/sys/unix/zsysnum_linux_mips64le.go | 2 + .../x/sys/unix/zsysnum_linux_mipsle.go | 2 + .../x/sys/unix/zsysnum_linux_ppc64.go | 2 + .../x/sys/unix/zsysnum_linux_ppc64le.go | 2 + .../x/sys/unix/zsysnum_linux_riscv64.go | 2 + .../x/sys/unix/zsysnum_linux_s390x.go | 2 + .../x/sys/unix/zsysnum_linux_sparc64.go | 2 + .../x/sys/unix/zsysnum_openbsd_mips64.go | 220 + .../x/sys/unix/ztypes_darwin_386.go | 32 +- .../x/sys/unix/ztypes_darwin_amd64.go | 43 +- .../x/sys/unix/ztypes_darwin_arm.go | 39 +- .../x/sys/unix/ztypes_darwin_arm64.go | 43 +- .../x/sys/unix/ztypes_dragonfly_amd64.go | 46 +- vendor/golang.org/x/sys/unix/ztypes_linux.go | 1102 +++- .../golang.org/x/sys/unix/ztypes_linux_386.go | 20 + .../x/sys/unix/ztypes_linux_amd64.go | 23 + .../golang.org/x/sys/unix/ztypes_linux_arm.go | 23 + .../x/sys/unix/ztypes_linux_arm64.go | 23 + .../x/sys/unix/ztypes_linux_mips.go | 23 + .../x/sys/unix/ztypes_linux_mips64.go | 23 + .../x/sys/unix/ztypes_linux_mips64le.go | 23 + .../x/sys/unix/ztypes_linux_mipsle.go | 23 + .../x/sys/unix/ztypes_linux_ppc64.go | 23 + .../x/sys/unix/ztypes_linux_ppc64le.go | 23 + .../x/sys/unix/ztypes_linux_riscv64.go | 23 + .../x/sys/unix/ztypes_linux_s390x.go | 23 + .../x/sys/unix/ztypes_linux_sparc64.go | 23 + .../x/sys/unix/ztypes_openbsd_mips64.go | 565 ++ .../x/sys/unix/ztypes_solaris_amd64.go | 31 +- vendor/golang.org/x/sys/windows/BUILD | 1 + .../x/sys/windows/memory_windows.go | 20 +- .../sys/windows/registry/zsyscall_windows.go | 39 +- vendor/golang.org/x/sys/windows/service.go | 2 + .../x/sys/windows/setupapierrors_windows.go | 100 + .../golang.org/x/sys/windows/svc/security.go | 98 + .../golang.org/x/sys/windows/svc/service.go | 5 + .../golang.org/x/sys/windows/svc/sys_amd64.s | 10 +- vendor/golang.org/x/sys/windows/syscall.go | 46 +- .../x/sys/windows/syscall_windows.go | 33 +- .../golang.org/x/sys/windows/types_windows.go | 12 - .../x/sys/windows/types_windows_386.go | 13 + .../x/sys/windows/types_windows_amd64.go | 12 + .../x/sys/windows/types_windows_arm.go | 13 + .../x/sys/windows/zsyscall_windows.go | 4397 ++++++--------- vendor/modules.txt | 8 +- 287 files changed, 14661 insertions(+), 9970 deletions(-) rename vendor/golang.org/x/net/idna/{tables12.00.go => tables12.0.0.go} (99%) create mode 100644 vendor/golang.org/x/net/idna/tables13.0.0.go create mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_unix.go create mode 100644 vendor/golang.org/x/net/internal/socket/cmsghdr_zos_s390x.go create mode 100644 vendor/golang.org/x/net/internal/socket/msghdr_zos_s390x.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_bsdvar.go create mode 100644 vendor/golang.org/x/net/internal/socket/sys_const_zos.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_darwin.go delete mode 100644 vendor/golang.org/x/net/internal/socket/sys_dragonfly.go rename vendor/golang.org/x/net/internal/socket/{sys_go1_11_darwin.go => sys_zos_s390x.go} (52%) create mode 100644 vendor/golang.org/x/net/internal/socket/sys_zos_s390x.s create mode 100644 vendor/golang.org/x/net/internal/socket/zsys_zos_s390x.go create mode 100644 vendor/golang.org/x/net/ipv4/control_zos.go create mode 100644 vendor/golang.org/x/net/ipv4/sys_zos.go create mode 100644 vendor/golang.org/x/net/ipv4/zsys_zos_s390x.go create mode 100644 vendor/golang.org/x/net/ipv6/icmp_zos.go create mode 100644 vendor/golang.org/x/net/ipv6/sys_zos.go create mode 100644 vendor/golang.org/x/net/ipv6/zsys_zos_s390x.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_netbsd_arm64.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_arm.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_ppc64x.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_s390x.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_zos.go create mode 100644 vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go create mode 100644 vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_386.1_11.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_amd64.1_11.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_arm.1_11.go delete mode 100644 vendor/golang.org/x/sys/unix/syscall_darwin_arm64.1_11.go create mode 100644 vendor/golang.org/x/sys/unix/syscall_linux_gc_arm.go create mode 100644 vendor/golang.org/x/sys/unix/syscall_openbsd_mips64.go create mode 100644 vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_11.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_11.go delete mode 100644 vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_11.go rename vendor/golang.org/x/sys/unix/{zsyscall_darwin_arm64.1_11.go => zsyscall_openbsd_mips64.go} (86%) create mode 100644 vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go create mode 100644 vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go create mode 100644 vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go create mode 100644 vendor/golang.org/x/sys/windows/setupapierrors_windows.go diff --git a/go.mod b/go.mod index 9c19156545b56..92576df93c3d3 100644 --- a/go.mod +++ b/go.mod @@ -99,9 +99,9 @@ require ( github.com/vmware/govmomi v0.20.3 go.etcd.io/etcd v0.5.0-alpha.5.0.20200819165624-17cef6e3e9d5 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6 - golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 + golang.org/x/sys v0.0.0-20201112073958-5cba982894dd golang.org/x/time v0.0.0-20191024005414-555d28b269f0 golang.org/x/tools v0.0.0-20200616133436-c1934b75d054 gonum.org/v1/gonum v0.6.2 @@ -426,10 +426,10 @@ replace ( golang.org/x/lint => golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f golang.org/x/mobile => golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028 golang.org/x/mod => golang.org/x/mod v0.3.0 - golang.org/x/net => golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net => golang.org/x/net v0.0.0-20201110031124-69a78807bb2b golang.org/x/oauth2 => golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6 golang.org/x/sync => golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e - golang.org/x/sys => golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 + golang.org/x/sys => golang.org/x/sys v0.0.0-20201112073958-5cba982894dd golang.org/x/text => golang.org/x/text v0.3.3 golang.org/x/time => golang.org/x/time v0.0.0-20191024005414-555d28b269f0 golang.org/x/tools => golang.org/x/tools v0.0.0-20200616133436-c1934b75d054 diff --git a/go.sum b/go.sum index 1e1eed65a9c55..9480a9ca8027a 100644 --- a/go.sum +++ b/go.sum @@ -486,14 +486,14 @@ golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRu golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6 h1:pE8b58s1HRDMi8RDc79m0HISf9D4TzseP40cEA6IGfs= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0 h1:/5xXl8Y5W96D+TtHSlonuFqGHIWVuyCkGJLwGh9JJFs= diff --git a/staging/src/k8s.io/api/go.sum b/staging/src/k8s.io/api/go.sum index fc205da8f16cf..1ced802e1ce5e 100644 --- a/staging/src/k8s.io/api/go.sum +++ b/staging/src/k8s.io/api/go.sum @@ -104,8 +104,8 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -116,7 +116,8 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= diff --git a/staging/src/k8s.io/apiextensions-apiserver/go.sum b/staging/src/k8s.io/apiextensions-apiserver/go.sum index 6509ef7570a32..d3ad0d282dcb6 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/go.sum +++ b/staging/src/k8s.io/apiextensions-apiserver/go.sum @@ -459,8 +459,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -497,8 +497,9 @@ golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/apimachinery/go.mod b/staging/src/k8s.io/apimachinery/go.mod index 00005fcf73a83..b10d3774ecd2f 100644 --- a/staging/src/k8s.io/apimachinery/go.mod +++ b/staging/src/k8s.io/apimachinery/go.mod @@ -26,9 +26,8 @@ require ( github.com/pkg/errors v0.9.1 // indirect github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.4.0 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 - golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 // indirect - golang.org/x/text v0.3.3 // indirect + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b + golang.org/x/sys v0.0.0-20201112073958-5cba982894dd // indirect google.golang.org/protobuf v1.24.0 // indirect gopkg.in/inf.v0 v0.9.1 gopkg.in/yaml.v2 v2.2.8 diff --git a/staging/src/k8s.io/apimachinery/go.sum b/staging/src/k8s.io/apimachinery/go.sum index c114497d153e4..365b00c6b6d1e 100644 --- a/staging/src/k8s.io/apimachinery/go.sum +++ b/staging/src/k8s.io/apimachinery/go.sum @@ -118,8 +118,8 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -130,8 +130,9 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= diff --git a/staging/src/k8s.io/apiserver/go.mod b/staging/src/k8s.io/apiserver/go.mod index 86947be4909d1..022a6703e3382 100644 --- a/staging/src/k8s.io/apiserver/go.mod +++ b/staging/src/k8s.io/apiserver/go.mod @@ -34,9 +34,9 @@ require ( go.etcd.io/etcd v0.5.0-alpha.5.0.20200819165624-17cef6e3e9d5 go.uber.org/zap v1.10.0 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e - golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 + golang.org/x/sys v0.0.0-20201112073958-5cba982894dd google.golang.org/grpc v1.27.0 gopkg.in/natefinch/lumberjack.v2 v2.0.0 gopkg.in/square/go-jose.v2 v2.2.2 diff --git a/staging/src/k8s.io/apiserver/go.sum b/staging/src/k8s.io/apiserver/go.sum index 6a81d221c6075..0bf410f97245a 100644 --- a/staging/src/k8s.io/apiserver/go.sum +++ b/staging/src/k8s.io/apiserver/go.sum @@ -358,8 +358,8 @@ golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -395,8 +395,9 @@ golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/cli-runtime/go.sum b/staging/src/k8s.io/cli-runtime/go.sum index 68712468b4add..4a4c2700b467a 100644 --- a/staging/src/k8s.io/cli-runtime/go.sum +++ b/staging/src/k8s.io/cli-runtime/go.sum @@ -303,8 +303,8 @@ golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -333,8 +333,9 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/client-go/go.mod b/staging/src/k8s.io/client-go/go.mod index ac15fefd0310d..ae0cca80da067 100644 --- a/staging/src/k8s.io/client-go/go.mod +++ b/staging/src/k8s.io/client-go/go.mod @@ -23,7 +23,7 @@ require ( github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.4.0 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6 golang.org/x/time v0.0.0-20191024005414-555d28b269f0 k8s.io/api v0.0.0 diff --git a/staging/src/k8s.io/client-go/go.sum b/staging/src/k8s.io/client-go/go.sum index 4928f7eab86d0..b8e616cb21210 100644 --- a/staging/src/k8s.io/client-go/go.sum +++ b/staging/src/k8s.io/client-go/go.sum @@ -214,8 +214,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -240,8 +240,9 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/cloud-provider/go.sum b/staging/src/k8s.io/cloud-provider/go.sum index 9003a4c7d5605..48135e2e28696 100644 --- a/staging/src/k8s.io/cloud-provider/go.sum +++ b/staging/src/k8s.io/cloud-provider/go.sum @@ -251,8 +251,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -283,8 +283,9 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/cluster-bootstrap/go.sum b/staging/src/k8s.io/cluster-bootstrap/go.sum index e29f077635d9d..2b9aec51abb57 100644 --- a/staging/src/k8s.io/cluster-bootstrap/go.sum +++ b/staging/src/k8s.io/cluster-bootstrap/go.sum @@ -103,8 +103,8 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -115,7 +115,8 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= diff --git a/staging/src/k8s.io/code-generator/go.mod b/staging/src/k8s.io/code-generator/go.mod index 36455df8c85a7..33bc52335971c 100644 --- a/staging/src/k8s.io/code-generator/go.mod +++ b/staging/src/k8s.io/code-generator/go.mod @@ -14,8 +14,7 @@ require ( github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.4.0 // indirect golang.org/x/mod v0.3.0 // indirect - golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect - golang.org/x/text v0.3.3 // indirect + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b // indirect golang.org/x/tools v0.0.0-20200616133436-c1934b75d054 // indirect k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14 k8s.io/klog/v2 v2.2.0 diff --git a/staging/src/k8s.io/code-generator/go.sum b/staging/src/k8s.io/code-generator/go.sum index 360770597063a..5dc4a58c67c25 100644 --- a/staging/src/k8s.io/code-generator/go.sum +++ b/staging/src/k8s.io/code-generator/go.sum @@ -92,14 +92,15 @@ golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= diff --git a/staging/src/k8s.io/component-base/go.sum b/staging/src/k8s.io/component-base/go.sum index 1dd5e20f62ffa..4f0b49957aefc 100644 --- a/staging/src/k8s.io/component-base/go.sum +++ b/staging/src/k8s.io/component-base/go.sum @@ -259,8 +259,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -291,8 +291,9 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/cri-api/go.mod b/staging/src/k8s.io/cri-api/go.mod index 7c4c699933642..7329efcc86b87 100644 --- a/staging/src/k8s.io/cri-api/go.mod +++ b/staging/src/k8s.io/cri-api/go.mod @@ -10,9 +10,8 @@ require ( github.com/golang/protobuf v1.4.2 // indirect github.com/kr/pretty v0.2.0 // indirect github.com/stretchr/testify v1.4.0 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect - golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 // indirect - golang.org/x/text v0.3.3 // indirect + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b // indirect + golang.org/x/sys v0.0.0-20201112073958-5cba982894dd // indirect google.golang.org/grpc v1.27.0 google.golang.org/protobuf v1.24.0 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect diff --git a/staging/src/k8s.io/cri-api/go.sum b/staging/src/k8s.io/cri-api/go.sum index 770eae3429644..f5346d2e8ad40 100644 --- a/staging/src/k8s.io/cri-api/go.sum +++ b/staging/src/k8s.io/cri-api/go.sum @@ -51,8 +51,8 @@ golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -60,9 +60,9 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= diff --git a/staging/src/k8s.io/csi-translation-lib/go.sum b/staging/src/k8s.io/csi-translation-lib/go.sum index 00d64e38a7103..6a35da4744574 100644 --- a/staging/src/k8s.io/csi-translation-lib/go.sum +++ b/staging/src/k8s.io/csi-translation-lib/go.sum @@ -232,8 +232,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -263,7 +263,8 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kube-aggregator/go.mod b/staging/src/k8s.io/kube-aggregator/go.mod index b81ad222608e6..f8a2901f885db 100644 --- a/staging/src/k8s.io/kube-aggregator/go.mod +++ b/staging/src/k8s.io/kube-aggregator/go.mod @@ -13,7 +13,7 @@ require ( github.com/spf13/cobra v1.0.0 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.4.0 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b k8s.io/api v0.0.0 k8s.io/apimachinery v0.0.0 k8s.io/apiserver v0.0.0 diff --git a/staging/src/k8s.io/kube-aggregator/go.sum b/staging/src/k8s.io/kube-aggregator/go.sum index 20f4aaa369a90..336aa7e6a5a7d 100644 --- a/staging/src/k8s.io/kube-aggregator/go.sum +++ b/staging/src/k8s.io/kube-aggregator/go.sum @@ -397,8 +397,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -434,8 +434,9 @@ golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kube-controller-manager/go.sum b/staging/src/k8s.io/kube-controller-manager/go.sum index 57ebfe792b40c..caf25957d7820 100644 --- a/staging/src/k8s.io/kube-controller-manager/go.sum +++ b/staging/src/k8s.io/kube-controller-manager/go.sum @@ -231,8 +231,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -262,7 +262,8 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kube-proxy/go.sum b/staging/src/k8s.io/kube-proxy/go.sum index 57ebfe792b40c..caf25957d7820 100644 --- a/staging/src/k8s.io/kube-proxy/go.sum +++ b/staging/src/k8s.io/kube-proxy/go.sum @@ -231,8 +231,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -262,7 +262,8 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kube-scheduler/go.sum b/staging/src/k8s.io/kube-scheduler/go.sum index 57ebfe792b40c..caf25957d7820 100644 --- a/staging/src/k8s.io/kube-scheduler/go.sum +++ b/staging/src/k8s.io/kube-scheduler/go.sum @@ -231,8 +231,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -262,7 +262,8 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kubectl/go.mod b/staging/src/k8s.io/kubectl/go.mod index 4757b8cbf78c0..190a4390ded8e 100644 --- a/staging/src/k8s.io/kubectl/go.mod +++ b/staging/src/k8s.io/kubectl/go.mod @@ -32,7 +32,7 @@ require ( github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.4.0 github.com/xlab/handysort v0.0.0-20150421192137-fb3537ed64a1 // indirect - golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 + golang.org/x/sys v0.0.0-20201112073958-5cba982894dd gopkg.in/yaml.v2 v2.2.8 k8s.io/api v0.0.0 k8s.io/apimachinery v0.0.0 diff --git a/staging/src/k8s.io/kubectl/go.sum b/staging/src/k8s.io/kubectl/go.sum index a3a6a68549ca3..6257d7f4233ed 100644 --- a/staging/src/k8s.io/kubectl/go.sum +++ b/staging/src/k8s.io/kubectl/go.sum @@ -367,8 +367,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -401,8 +401,9 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/kubelet/go.mod b/staging/src/k8s.io/kubelet/go.mod index 7c5ff187d76e1..c1029c645a944 100644 --- a/staging/src/k8s.io/kubelet/go.mod +++ b/staging/src/k8s.io/kubelet/go.mod @@ -6,7 +6,7 @@ go 1.15 require ( github.com/gogo/protobuf v1.3.1 - golang.org/x/net v0.0.0-20200707034311-ab3426394381 + golang.org/x/net v0.0.0-20201110031124-69a78807bb2b google.golang.org/grpc v1.27.0 k8s.io/api v0.0.0 k8s.io/apimachinery v0.0.0 diff --git a/staging/src/k8s.io/kubelet/go.sum b/staging/src/k8s.io/kubelet/go.sum index 0e5b24ecfbfb8..07fa3d22a0ffa 100644 --- a/staging/src/k8s.io/kubelet/go.sum +++ b/staging/src/k8s.io/kubelet/go.sum @@ -234,8 +234,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -265,8 +265,9 @@ golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/legacy-cloud-providers/go.sum b/staging/src/k8s.io/legacy-cloud-providers/go.sum index 4c13cddb3a488..c689b31b216f6 100644 --- a/staging/src/k8s.io/legacy-cloud-providers/go.sum +++ b/staging/src/k8s.io/legacy-cloud-providers/go.sum @@ -362,8 +362,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -400,8 +400,9 @@ golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/metrics/go.sum b/staging/src/k8s.io/metrics/go.sum index f8f129563cf8c..30008bb4c27e3 100644 --- a/staging/src/k8s.io/metrics/go.sum +++ b/staging/src/k8s.io/metrics/go.sum @@ -224,8 +224,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -251,8 +251,9 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/sample-apiserver/go.sum b/staging/src/k8s.io/sample-apiserver/go.sum index 2eff56678f8bb..b5ae85ebae18d 100644 --- a/staging/src/k8s.io/sample-apiserver/go.sum +++ b/staging/src/k8s.io/sample-apiserver/go.sum @@ -394,8 +394,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -431,8 +431,9 @@ golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/sample-cli-plugin/go.sum b/staging/src/k8s.io/sample-cli-plugin/go.sum index 68712468b4add..4a4c2700b467a 100644 --- a/staging/src/k8s.io/sample-cli-plugin/go.sum +++ b/staging/src/k8s.io/sample-cli-plugin/go.sum @@ -303,8 +303,8 @@ golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -333,8 +333,9 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/staging/src/k8s.io/sample-controller/go.sum b/staging/src/k8s.io/sample-controller/go.sum index 3e6c142a2151c..c51663ffc79ba 100644 --- a/staging/src/k8s.io/sample-controller/go.sum +++ b/staging/src/k8s.io/sample-controller/go.sum @@ -228,8 +228,8 @@ golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -255,8 +255,9 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4 h1:5/PjkGUjvEU5Gl6BxmvKRPpqo2uNMv4rcHBMwzk/st8= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY= +golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= diff --git a/vendor/golang.org/x/net/html/const.go b/vendor/golang.org/x/net/html/const.go index 73804d3472cff..ff7acf2d5b4b2 100644 --- a/vendor/golang.org/x/net/html/const.go +++ b/vendor/golang.org/x/net/html/const.go @@ -52,7 +52,7 @@ var isSpecialElementMap = map[string]bool{ "iframe": true, "img": true, "input": true, - "keygen": true, + "keygen": true, // "keygen" has been removed from the spec, but are kept here for backwards compatibility. "li": true, "link": true, "listing": true, diff --git a/vendor/golang.org/x/net/html/foreign.go b/vendor/golang.org/x/net/html/foreign.go index 74774c458ae6f..9da9e9dc42463 100644 --- a/vendor/golang.org/x/net/html/foreign.go +++ b/vendor/golang.org/x/net/html/foreign.go @@ -161,65 +161,62 @@ var mathMLAttributeAdjustments = map[string]string{ } var svgAttributeAdjustments = map[string]string{ - "attributename": "attributeName", - "attributetype": "attributeType", - "basefrequency": "baseFrequency", - "baseprofile": "baseProfile", - "calcmode": "calcMode", - "clippathunits": "clipPathUnits", - "contentscripttype": "contentScriptType", - "contentstyletype": "contentStyleType", - "diffuseconstant": "diffuseConstant", - "edgemode": "edgeMode", - "externalresourcesrequired": "externalResourcesRequired", - "filterunits": "filterUnits", - "glyphref": "glyphRef", - "gradienttransform": "gradientTransform", - "gradientunits": "gradientUnits", - "kernelmatrix": "kernelMatrix", - "kernelunitlength": "kernelUnitLength", - "keypoints": "keyPoints", - "keysplines": "keySplines", - "keytimes": "keyTimes", - "lengthadjust": "lengthAdjust", - "limitingconeangle": "limitingConeAngle", - "markerheight": "markerHeight", - "markerunits": "markerUnits", - "markerwidth": "markerWidth", - "maskcontentunits": "maskContentUnits", - "maskunits": "maskUnits", - "numoctaves": "numOctaves", - "pathlength": "pathLength", - "patterncontentunits": "patternContentUnits", - "patterntransform": "patternTransform", - "patternunits": "patternUnits", - "pointsatx": "pointsAtX", - "pointsaty": "pointsAtY", - "pointsatz": "pointsAtZ", - "preservealpha": "preserveAlpha", - "preserveaspectratio": "preserveAspectRatio", - "primitiveunits": "primitiveUnits", - "refx": "refX", - "refy": "refY", - "repeatcount": "repeatCount", - "repeatdur": "repeatDur", - "requiredextensions": "requiredExtensions", - "requiredfeatures": "requiredFeatures", - "specularconstant": "specularConstant", - "specularexponent": "specularExponent", - "spreadmethod": "spreadMethod", - "startoffset": "startOffset", - "stddeviation": "stdDeviation", - "stitchtiles": "stitchTiles", - "surfacescale": "surfaceScale", - "systemlanguage": "systemLanguage", - "tablevalues": "tableValues", - "targetx": "targetX", - "targety": "targetY", - "textlength": "textLength", - "viewbox": "viewBox", - "viewtarget": "viewTarget", - "xchannelselector": "xChannelSelector", - "ychannelselector": "yChannelSelector", - "zoomandpan": "zoomAndPan", + "attributename": "attributeName", + "attributetype": "attributeType", + "basefrequency": "baseFrequency", + "baseprofile": "baseProfile", + "calcmode": "calcMode", + "clippathunits": "clipPathUnits", + "diffuseconstant": "diffuseConstant", + "edgemode": "edgeMode", + "filterunits": "filterUnits", + "glyphref": "glyphRef", + "gradienttransform": "gradientTransform", + "gradientunits": "gradientUnits", + "kernelmatrix": "kernelMatrix", + "kernelunitlength": "kernelUnitLength", + "keypoints": "keyPoints", + "keysplines": "keySplines", + "keytimes": "keyTimes", + "lengthadjust": "lengthAdjust", + "limitingconeangle": "limitingConeAngle", + "markerheight": "markerHeight", + "markerunits": "markerUnits", + "markerwidth": "markerWidth", + "maskcontentunits": "maskContentUnits", + "maskunits": "maskUnits", + "numoctaves": "numOctaves", + "pathlength": "pathLength", + "patterncontentunits": "patternContentUnits", + "patterntransform": "patternTransform", + "patternunits": "patternUnits", + "pointsatx": "pointsAtX", + "pointsaty": "pointsAtY", + "pointsatz": "pointsAtZ", + "preservealpha": "preserveAlpha", + "preserveaspectratio": "preserveAspectRatio", + "primitiveunits": "primitiveUnits", + "refx": "refX", + "refy": "refY", + "repeatcount": "repeatCount", + "repeatdur": "repeatDur", + "requiredextensions": "requiredExtensions", + "requiredfeatures": "requiredFeatures", + "specularconstant": "specularConstant", + "specularexponent": "specularExponent", + "spreadmethod": "spreadMethod", + "startoffset": "startOffset", + "stddeviation": "stdDeviation", + "stitchtiles": "stitchTiles", + "surfacescale": "surfaceScale", + "systemlanguage": "systemLanguage", + "tablevalues": "tableValues", + "targetx": "targetX", + "targety": "targetY", + "textlength": "textLength", + "viewbox": "viewBox", + "viewtarget": "viewTarget", + "xchannelselector": "xChannelSelector", + "ychannelselector": "yChannelSelector", + "zoomandpan": "zoomAndPan", } diff --git a/vendor/golang.org/x/net/html/parse.go b/vendor/golang.org/x/net/html/parse.go index 2cd12fc816e71..f91466f7cd745 100644 --- a/vendor/golang.org/x/net/html/parse.go +++ b/vendor/golang.org/x/net/html/parse.go @@ -728,7 +728,13 @@ func inHeadNoscriptIM(p *parser) bool { return inBodyIM(p) case a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Style: return inHeadIM(p) - case a.Head, a.Noscript: + case a.Head: + // Ignore the token. + return true + case a.Noscript: + // Don't let the tokenizer go into raw text mode even when a