github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-02 00:07:50 +00:00
Code Issues Projects Releases Wiki Activity

Remove checks of the CloudDualStackNodeIPs feature gate

Browse Source
This commit is contained in:
Dan Winship 2024-02-05 10:26:37 -05:00
parent eba4fd82eb
commit 4ddf69a835
6 changed files with 36 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/kubelet/app/server.go
View File

@ -1208,7 +1208,7 @@ func RunKubelet(kubeServer *options.KubeletServer, kubeDeps *kubelet.Dependencie
// Setup event recorder if required. // Setup event recorder if required.
makeEventRecorder(context.TODO(), kubeDeps, nodeName) 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 { if err != nil {
return fmt.Errorf("bad --node-ip %q: %v", kubeServer.NodeIP, err) return fmt.Errorf("bad --node-ip %q: %v", kubeServer.NodeIP, err)
} }

4
staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go
View File

@ -29,7 +29,6 @@ import (
"k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/types"
utilruntime "k8s.io/apimachinery/pkg/util/runtime" utilruntime "k8s.io/apimachinery/pkg/util/runtime"
"k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/util/wait"
utilfeature "k8s.io/apiserver/pkg/util/feature"
coreinformers "k8s.io/client-go/informers/core/v1" coreinformers "k8s.io/client-go/informers/core/v1"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/kubernetes/scheme"
@ -44,7 +43,6 @@ import (
cloudnodeutil "k8s.io/cloud-provider/node/helpers" cloudnodeutil "k8s.io/cloud-provider/node/helpers"
controllersmetrics "k8s.io/component-base/metrics/prometheus/controllers" controllersmetrics "k8s.io/component-base/metrics/prometheus/controllers"
nodeutil "k8s.io/component-helpers/node/util" nodeutil "k8s.io/component-helpers/node/util"
"k8s.io/controller-manager/pkg/features"
"k8s.io/klog/v2" "k8s.io/klog/v2"
) )
@ -748,7 +746,7 @@ func updateNodeAddressesFromNodeIP(node *v1.Node, nodeAddresses []v1.NodeAddress
providedNodeIP, exists := node.ObjectMeta.Annotations[cloudproviderapi.AnnotationAlphaProvidedIPAddr] providedNodeIP, exists := node.ObjectMeta.Annotations[cloudproviderapi.AnnotationAlphaProvidedIPAddr]
if exists { if exists {
nodeAddresses, err = cloudnodeutil.GetNodeAddressesFromNodeIP(providedNodeIP, nodeAddresses, utilfeature.DefaultFeatureGate.Enabled(features.CloudDualStackNodeIPs)) nodeAddresses, err = cloudnodeutil.GetNodeAddressesFromNodeIP(providedNodeIP, nodeAddresses)
} }
return nodeAddresses, err return nodeAddresses, err

6
staging/src/k8s.io/cloud-provider/node/helpers/address.go
View File

@ -85,7 +85,7 @@ func GetNodeAddressesFromNodeIPLegacy(nodeIP net.IP, cloudNodeAddresses []v1.Nod
} }
// Otherwise the result is the same as for GetNodeAddressesFromNodeIP // 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 // 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 // GetNodeAddressesFromNodeIPLegacy, because that case never occurs for external cloud
// providers, because kubelet does not set the `provided-node-ip` annotation in that // providers, because kubelet does not set the `provided-node-ip` annotation in that
// case.) // case.)
func GetNodeAddressesFromNodeIP(providedNodeIP string, cloudNodeAddresses []v1.NodeAddress, allowDualStack bool) ([]v1.NodeAddress, error) { func GetNodeAddressesFromNodeIP(providedNodeIP string, cloudNodeAddresses []v1.NodeAddress) ([]v1.NodeAddress, error) {
nodeIPs, err := nodeutil.ParseNodeIPAnnotation(providedNodeIP, allowDualStack) nodeIPs, err := nodeutil.ParseNodeIPAnnotation(providedNodeIP)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to parse node IP %q: %v", providedNodeIP, err) return nil, fmt.Errorf("failed to parse node IP %q: %v", providedNodeIP, err)
} }

2
staging/src/k8s.io/cloud-provider/node/helpers/address_test.go
View File

@ -552,7 +552,7 @@ func TestGetNodeAddressesFromNodeIP(t *testing.T) {
for _, tt := range cases { for _, tt := range cases {
t.Run(tt.name, func(t *testing.T) { 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 { if (err != nil) != tt.shouldError {
t.Errorf("GetNodeAddressesFromNodeIP() error = %v, wantErr %v", err, tt.shouldError) t.Errorf("GetNodeAddressesFromNodeIP() error = %v, wantErr %v", err, tt.shouldError)
return return

15
staging/src/k8s.io/component-helpers/node/util/ips.go
View File

@ -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 // 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 // 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. // cloudProvider is unset or `"external"`.
func ParseNodeIPArgument(nodeIP, cloudProvider string, allowCloudDualStack bool) ([]net.IP, error) { func ParseNodeIPArgument(nodeIP, cloudProvider string) ([]net.IP, error) {
var allowDualStack bool var allowDualStack bool
if (cloudProvider == cloudProviderNone) || (cloudProvider == cloudProviderExternal && allowCloudDualStack) { if cloudProvider == cloudProviderNone || cloudProvider == cloudProviderExternal {
allowDualStack = true allowDualStack = true
} }
return parseNodeIP(nodeIP, allowDualStack, true) return parseNodeIP(nodeIP, allowDualStack, true)
} }
// ParseNodeIPAnnotation parses the `alpha.kubernetes.io/provided-node-ip` annotation, // ParseNodeIPAnnotation parses the `alpha.kubernetes.io/provided-node-ip` annotation,
// which can be either a single IP address or (if allowDualStack is true) a // which can be either a single IP address or a comma-separated pair of IP addresses.
// comma-separated pair of IP addresses. Unlike with ParseNodeIPArgument, invalid values // Unlike with ParseNodeIPArgument, invalid values are considered an error.
// are considered an error. func ParseNodeIPAnnotation(nodeIP string) ([]net.IP, error) {
func ParseNodeIPAnnotation(nodeIP string, allowDualStack bool) ([]net.IP, error) { return parseNodeIP(nodeIP, true, false)
return parseNodeIP(nodeIP, allowDualStack, false)
} }

62
staging/src/k8s.io/component-helpers/node/util/ips_test.go
View File

@ -165,23 +165,19 @@ func TestParseNodeIPArgument(t *testing.T) {
} }
configurations := []struct { configurations := []struct {
cloudProvider string cloudProvider string
allowCloudDualStack bool dualStackSupported bool
dualStackSupported bool
}{ }{
{cloudProviderNone, false, true}, {cloudProviderNone, true},
{cloudProviderNone, true, true}, {cloudProviderExternal, true},
{cloudProviderExternal, false, false}, {"gce", false},
{cloudProviderExternal, true, true},
{"gce", false, false},
{"gce", true, false},
} }
for _, tc := range testCases { for _, tc := range testCases {
for _, conf := range configurations { 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) { 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 expectedOut := tc.out
expectedErr := tc.err expectedErr := tc.err
@ -339,36 +335,24 @@ func TestParseNodeIPAnnotation(t *testing.T) {
} }
for _, tc := range testCases { for _, tc := range testCases {
for _, allowDualStack := range []bool{false, true} { t.Run(tc.desc, func(t *testing.T) {
desc := fmt.Sprintf("%s, allowDualStack=%v", tc.desc, allowDualStack) parsed, err := ParseNodeIPAnnotation(tc.in)
t.Run(desc, func(t *testing.T) {
parsed, err := ParseNodeIPAnnotation(tc.in, allowDualStack)
expectedOut := tc.out expectedOut := tc.out
expectedErr := tc.err expectedErr := tc.err
if !allowDualStack { if !reflect.DeepEqual(parsed, expectedOut) {
if len(tc.out) == 2 { t.Errorf("expected %#v, got %#v", expectedOut, parsed)
expectedOut = nil }
} if err != nil {
if tc.ssErr != "" { if expectedErr == "" {
expectedErr = tc.ssErr 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 != "" {
if !reflect.DeepEqual(parsed, expectedOut) { t.Errorf("expected error with %q, got no error", expectedErr)
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)
}
})
}
} }
} }