diff --git a/cmd/kubelet/app/server.go b/cmd/kubelet/app/server.go index aba3cd00256..9a9338e7705 100644 --- a/cmd/kubelet/app/server.go +++ b/cmd/kubelet/app/server.go @@ -1208,7 +1208,7 @@ func RunKubelet(kubeServer *options.KubeletServer, kubeDeps *kubelet.Dependencie // Setup event recorder if required. makeEventRecorder(context.TODO(), kubeDeps, nodeName) - nodeIPs, err := nodeutil.ParseNodeIPArgument(kubeServer.NodeIP, kubeServer.CloudProvider, utilfeature.DefaultFeatureGate.Enabled(features.CloudDualStackNodeIPs)) + nodeIPs, err := nodeutil.ParseNodeIPArgument(kubeServer.NodeIP, kubeServer.CloudProvider) if err != nil { return fmt.Errorf("bad --node-ip %q: %v", kubeServer.NodeIP, err) } diff --git a/staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go b/staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go index 06d2030ff96..4cdd4ce05c3 100644 --- a/staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go +++ b/staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go @@ -29,7 +29,6 @@ import ( "k8s.io/apimachinery/pkg/types" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" - utilfeature "k8s.io/apiserver/pkg/util/feature" coreinformers "k8s.io/client-go/informers/core/v1" clientset "k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes/scheme" @@ -44,7 +43,6 @@ import ( cloudnodeutil "k8s.io/cloud-provider/node/helpers" controllersmetrics "k8s.io/component-base/metrics/prometheus/controllers" nodeutil "k8s.io/component-helpers/node/util" - "k8s.io/controller-manager/pkg/features" "k8s.io/klog/v2" ) @@ -748,7 +746,7 @@ func updateNodeAddressesFromNodeIP(node *v1.Node, nodeAddresses []v1.NodeAddress providedNodeIP, exists := node.ObjectMeta.Annotations[cloudproviderapi.AnnotationAlphaProvidedIPAddr] if exists { - nodeAddresses, err = cloudnodeutil.GetNodeAddressesFromNodeIP(providedNodeIP, nodeAddresses, utilfeature.DefaultFeatureGate.Enabled(features.CloudDualStackNodeIPs)) + nodeAddresses, err = cloudnodeutil.GetNodeAddressesFromNodeIP(providedNodeIP, nodeAddresses) } return nodeAddresses, err diff --git a/staging/src/k8s.io/cloud-provider/node/helpers/address.go b/staging/src/k8s.io/cloud-provider/node/helpers/address.go index 41112cdaeb3..2bed1984267 100644 --- a/staging/src/k8s.io/cloud-provider/node/helpers/address.go +++ b/staging/src/k8s.io/cloud-provider/node/helpers/address.go @@ -85,7 +85,7 @@ func GetNodeAddressesFromNodeIPLegacy(nodeIP net.IP, cloudNodeAddresses []v1.Nod } // Otherwise the result is the same as for GetNodeAddressesFromNodeIP - return GetNodeAddressesFromNodeIP(nodeIP.String(), cloudNodeAddresses, false) + return GetNodeAddressesFromNodeIP(nodeIP.String(), cloudNodeAddresses) } // GetNodeAddressesFromNodeIP filters the provided list of nodeAddresses to match the @@ -102,8 +102,8 @@ func GetNodeAddressesFromNodeIPLegacy(nodeIP net.IP, cloudNodeAddresses []v1.Nod // GetNodeAddressesFromNodeIPLegacy, because that case never occurs for external cloud // providers, because kubelet does not set the `provided-node-ip` annotation in that // case.) -func GetNodeAddressesFromNodeIP(providedNodeIP string, cloudNodeAddresses []v1.NodeAddress, allowDualStack bool) ([]v1.NodeAddress, error) { - nodeIPs, err := nodeutil.ParseNodeIPAnnotation(providedNodeIP, allowDualStack) +func GetNodeAddressesFromNodeIP(providedNodeIP string, cloudNodeAddresses []v1.NodeAddress) ([]v1.NodeAddress, error) { + nodeIPs, err := nodeutil.ParseNodeIPAnnotation(providedNodeIP) if err != nil { return nil, fmt.Errorf("failed to parse node IP %q: %v", providedNodeIP, err) } diff --git a/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go b/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go index cf208df1a28..01208c6a06a 100644 --- a/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go +++ b/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go @@ -552,7 +552,7 @@ func TestGetNodeAddressesFromNodeIP(t *testing.T) { for _, tt := range cases { t.Run(tt.name, func(t *testing.T) { - got, err := GetNodeAddressesFromNodeIP(tt.nodeIP, tt.nodeAddresses, true) + got, err := GetNodeAddressesFromNodeIP(tt.nodeIP, tt.nodeAddresses) if (err != nil) != tt.shouldError { t.Errorf("GetNodeAddressesFromNodeIP() error = %v, wantErr %v", err, tt.shouldError) return diff --git a/staging/src/k8s.io/component-helpers/node/util/ips.go b/staging/src/k8s.io/component-helpers/node/util/ips.go index ff306a3dc3c..cf63cc3829e 100644 --- a/staging/src/k8s.io/component-helpers/node/util/ips.go +++ b/staging/src/k8s.io/component-helpers/node/util/ips.go @@ -64,19 +64,18 @@ func parseNodeIP(nodeIP string, allowDual, sloppy bool) ([]net.IP, error) { // ParseNodeIPArgument parses kubelet's --node-ip argument. If nodeIP contains invalid // values, they will be logged and ignored. Dual-stack node IPs are allowed if -// cloudProvider is unset, or if it is `"external"` and allowCloudDualStack is true. -func ParseNodeIPArgument(nodeIP, cloudProvider string, allowCloudDualStack bool) ([]net.IP, error) { +// cloudProvider is unset or `"external"`. +func ParseNodeIPArgument(nodeIP, cloudProvider string) ([]net.IP, error) { var allowDualStack bool - if (cloudProvider == cloudProviderNone) || (cloudProvider == cloudProviderExternal && allowCloudDualStack) { + if cloudProvider == cloudProviderNone || cloudProvider == cloudProviderExternal { allowDualStack = true } return parseNodeIP(nodeIP, allowDualStack, true) } // ParseNodeIPAnnotation parses the `alpha.kubernetes.io/provided-node-ip` annotation, -// which can be either a single IP address or (if allowDualStack is true) a -// comma-separated pair of IP addresses. Unlike with ParseNodeIPArgument, invalid values -// are considered an error. -func ParseNodeIPAnnotation(nodeIP string, allowDualStack bool) ([]net.IP, error) { - return parseNodeIP(nodeIP, allowDualStack, false) +// which can be either a single IP address or a comma-separated pair of IP addresses. +// Unlike with ParseNodeIPArgument, invalid values are considered an error. +func ParseNodeIPAnnotation(nodeIP string) ([]net.IP, error) { + return parseNodeIP(nodeIP, true, false) } diff --git a/staging/src/k8s.io/component-helpers/node/util/ips_test.go b/staging/src/k8s.io/component-helpers/node/util/ips_test.go index 0d3586ef582..4449bac84c0 100644 --- a/staging/src/k8s.io/component-helpers/node/util/ips_test.go +++ b/staging/src/k8s.io/component-helpers/node/util/ips_test.go @@ -165,23 +165,19 @@ func TestParseNodeIPArgument(t *testing.T) { } configurations := []struct { - cloudProvider string - allowCloudDualStack bool - dualStackSupported bool + cloudProvider string + dualStackSupported bool }{ - {cloudProviderNone, false, true}, - {cloudProviderNone, true, true}, - {cloudProviderExternal, false, false}, - {cloudProviderExternal, true, true}, - {"gce", false, false}, - {"gce", true, false}, + {cloudProviderNone, true}, + {cloudProviderExternal, true}, + {"gce", false}, } for _, tc := range testCases { for _, conf := range configurations { - desc := fmt.Sprintf("%s, cloudProvider=%q, allowCloudDualStack=%v", tc.desc, conf.cloudProvider, conf.allowCloudDualStack) + desc := fmt.Sprintf("%s, cloudProvider=%q", tc.desc, conf.cloudProvider) t.Run(desc, func(t *testing.T) { - parsed, err := ParseNodeIPArgument(tc.in, conf.cloudProvider, conf.allowCloudDualStack) + parsed, err := ParseNodeIPArgument(tc.in, conf.cloudProvider) expectedOut := tc.out expectedErr := tc.err @@ -339,36 +335,24 @@ func TestParseNodeIPAnnotation(t *testing.T) { } for _, tc := range testCases { - for _, allowDualStack := range []bool{false, true} { - desc := fmt.Sprintf("%s, allowDualStack=%v", tc.desc, allowDualStack) - t.Run(desc, func(t *testing.T) { - parsed, err := ParseNodeIPAnnotation(tc.in, allowDualStack) + t.Run(tc.desc, func(t *testing.T) { + parsed, err := ParseNodeIPAnnotation(tc.in) - expectedOut := tc.out - expectedErr := tc.err + expectedOut := tc.out + expectedErr := tc.err - if !allowDualStack { - if len(tc.out) == 2 { - expectedOut = nil - } - if tc.ssErr != "" { - expectedErr = tc.ssErr - } + if !reflect.DeepEqual(parsed, expectedOut) { + t.Errorf("expected %#v, got %#v", expectedOut, parsed) + } + if err != nil { + if expectedErr == "" { + t.Errorf("unexpected error %v", err) + } else if !strings.Contains(err.Error(), expectedErr) { + t.Errorf("expected error with %q, got %v", expectedErr, err) } - - if !reflect.DeepEqual(parsed, expectedOut) { - t.Errorf("expected %#v, got %#v", expectedOut, parsed) - } - if err != nil { - if expectedErr == "" { - t.Errorf("unexpected error %v", err) - } else if !strings.Contains(err.Error(), expectedErr) { - t.Errorf("expected error with %q, got %v", expectedErr, err) - } - } else if expectedErr != "" { - t.Errorf("expected error with %q, got no error", expectedErr) - } - }) - } + } else if expectedErr != "" { + t.Errorf("expected error with %q, got no error", expectedErr) + } + }) } }