use utils/ptr package instead of utils/pointer

Signed-off-by: sivchari <[email protected]>

Author: sivchari

pkg/kubelet/apis/config/fuzzer/fuzzer.go

@@ -31,7 +31,7 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/eviction"
 	"k8s.io/kubernetes/pkg/kubelet/qos"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
-	utilpointer "k8s.io/utils/pointer"
+	"k8s.io/utils/ptr"
 )
 
 // Funcs returns the fuzzer functions for the kubeletconfig apis.
@@ -118,7 +118,7 @@ func Funcs(codecs runtimeserializer.CodecFactory) []interface{} {
 				obj.Logging.Format = "text"
 			}
 			obj.EnableSystemLogHandler = true
-			obj.MemoryThrottlingFactor = utilpointer.Float64(rand.Float64())
+			obj.MemoryThrottlingFactor = ptr.To(rand.Float64())
 			obj.LocalStorageCapacityIsolation = true
 		},
 	}

pkg/kubelet/apis/config/v1beta1/defaults.go

@@ -28,7 +28,7 @@ import (
 	"k8s.io/kubernetes/pkg/cluster/ports"
 	"k8s.io/kubernetes/pkg/kubelet/qos"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
-	utilpointer "k8s.io/utils/pointer"
+	"k8s.io/utils/ptr"
 )
 
 const (
@@ -54,7 +54,7 @@ func addDefaultingFuncs(scheme *kruntime.Scheme) error {
 
 func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfiguration) {
 	if obj.EnableServer == nil {
-		obj.EnableServer = utilpointer.Bool(true)
+		obj.EnableServer = ptr.To(true)
 	}
 	if obj.SyncFrequency == zeroDuration {
 		obj.SyncFrequency = metav1.Duration{Duration: 1 * time.Minute}
@@ -72,10 +72,10 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 		obj.Port = ports.KubeletPort
 	}
 	if obj.Authentication.Anonymous.Enabled == nil {
-		obj.Authentication.Anonymous.Enabled = utilpointer.Bool(false)
+		obj.Authentication.Anonymous.Enabled = ptr.To(false)
 	}
 	if obj.Authentication.Webhook.Enabled == nil {
-		obj.Authentication.Webhook.Enabled = utilpointer.Bool(true)
+		obj.Authentication.Webhook.Enabled = ptr.To(true)
 	}
 	if obj.Authentication.Webhook.CacheTTL == zeroDuration {
 		obj.Authentication.Webhook.CacheTTL = metav1.Duration{Duration: 2 * time.Minute}
@@ -90,28 +90,28 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 		obj.Authorization.Webhook.CacheUnauthorizedTTL = metav1.Duration{Duration: 30 * time.Second}
 	}
 	if obj.RegistryPullQPS == nil {
-		obj.RegistryPullQPS = utilpointer.Int32(5)
+		obj.RegistryPullQPS = ptr.To[int32](5)
 	}
 	if obj.RegistryBurst == 0 {
 		obj.RegistryBurst = 10
 	}
 	if obj.EventRecordQPS == nil {
-		obj.EventRecordQPS = utilpointer.Int32(50)
+		obj.EventRecordQPS = ptr.To[int32](50)
 	}
 	if obj.EventBurst == 0 {
 		obj.EventBurst = 100
 	}
 	if obj.EnableDebuggingHandlers == nil {
-		obj.EnableDebuggingHandlers = utilpointer.Bool(true)
+		obj.EnableDebuggingHandlers = ptr.To(true)
 	}
 	if obj.HealthzPort == nil {
-		obj.HealthzPort = utilpointer.Int32(10248)
+		obj.HealthzPort = ptr.To[int32](10248)
 	}
 	if obj.HealthzBindAddress == "" {
 		obj.HealthzBindAddress = "127.0.0.1"
 	}
 	if obj.OOMScoreAdj == nil {
-		obj.OOMScoreAdj = utilpointer.Int32(int32(qos.KubeletOOMScoreAdj))
+		obj.OOMScoreAdj = ptr.To(int32(qos.KubeletOOMScoreAdj))
 	}
 	if obj.StreamingConnectionIdleTimeout == zeroDuration {
 		obj.StreamingConnectionIdleTimeout = metav1.Duration{Duration: 4 * time.Hour}
@@ -137,16 +137,16 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 	}
 	if obj.ImageGCHighThresholdPercent == nil {
 		// default is below docker's default dm.min_free_space of 90%
-		obj.ImageGCHighThresholdPercent = utilpointer.Int32(85)
+		obj.ImageGCHighThresholdPercent = ptr.To[int32](85)
 	}
 	if obj.ImageGCLowThresholdPercent == nil {
-		obj.ImageGCLowThresholdPercent = utilpointer.Int32(80)
+		obj.ImageGCLowThresholdPercent = ptr.To[int32](80)
 	}
 	if obj.VolumeStatsAggPeriod == zeroDuration {
 		obj.VolumeStatsAggPeriod = metav1.Duration{Duration: time.Minute}
 	}
 	if obj.CgroupsPerQOS == nil {
-		obj.CgroupsPerQOS = utilpointer.Bool(true)
+		obj.CgroupsPerQOS = ptr.To(true)
 	}
 	if obj.CgroupDriver == "" {
 		obj.CgroupDriver = "cgroupfs"
@@ -178,20 +178,20 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 	}
 	// default nil or negative value to -1 (implies node allocatable pid limit)
 	if obj.PodPidsLimit == nil || *obj.PodPidsLimit < int64(0) {
-		obj.PodPidsLimit = utilpointer.Int64(-1)
+		obj.PodPidsLimit = ptr.To[int64](-1)
 	}
 
 	if obj.ResolverConfig == nil {
-		obj.ResolverConfig = utilpointer.String(kubetypes.ResolvConfDefault)
+		obj.ResolverConfig = ptr.To(kubetypes.ResolvConfDefault)
 	}
 	if obj.CPUCFSQuota == nil {
-		obj.CPUCFSQuota = utilpointer.Bool(true)
+		obj.CPUCFSQuota = ptr.To(true)
 	}
 	if obj.CPUCFSQuotaPeriod == nil {
 		obj.CPUCFSQuotaPeriod = &metav1.Duration{Duration: 100 * time.Millisecond}
 	}
 	if obj.NodeStatusMaxImages == nil {
-		obj.NodeStatusMaxImages = utilpointer.Int32(50)
+		obj.NodeStatusMaxImages = ptr.To[int32](50)
 	}
 	if obj.MaxOpenFiles == 0 {
 		obj.MaxOpenFiles = 1000000
@@ -200,7 +200,7 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 		obj.ContentType = "application/vnd.kubernetes.protobuf"
 	}
 	if obj.KubeAPIQPS == nil {
-		obj.KubeAPIQPS = utilpointer.Int32(50)
+		obj.KubeAPIQPS = ptr.To[int32](50)
 	}
 	if obj.KubeAPIBurst == 0 {
 		obj.KubeAPIBurst = 100
@@ -210,37 +210,37 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 		// is not set, and false when MaxParallelImagePulls is set.
 		// This is to save users from having to set both configs.
 		if obj.MaxParallelImagePulls == nil || *obj.MaxParallelImagePulls < 2 {
-			obj.SerializeImagePulls = utilpointer.Bool(true)
+			obj.SerializeImagePulls = ptr.To(true)
 		} else {
-			obj.SerializeImagePulls = utilpointer.Bool(false)
+			obj.SerializeImagePulls = ptr.To(false)
 		}
 	}
 	if obj.EvictionPressureTransitionPeriod == zeroDuration {
 		obj.EvictionPressureTransitionPeriod = metav1.Duration{Duration: 5 * time.Minute}
 	}
 	if obj.EnableControllerAttachDetach == nil {
-		obj.EnableControllerAttachDetach = utilpointer.Bool(true)
+		obj.EnableControllerAttachDetach = ptr.To(true)
 	}
 	if obj.MakeIPTablesUtilChains == nil {
-		obj.MakeIPTablesUtilChains = utilpointer.Bool(true)
+		obj.MakeIPTablesUtilChains = ptr.To(true)
 	}
 	if obj.IPTablesMasqueradeBit == nil {
-		obj.IPTablesMasqueradeBit = utilpointer.Int32(DefaultIPTablesMasqueradeBit)
+		obj.IPTablesMasqueradeBit = ptr.To[int32](DefaultIPTablesMasqueradeBit)
 	}
 	if obj.IPTablesDropBit == nil {
-		obj.IPTablesDropBit = utilpointer.Int32(DefaultIPTablesDropBit)
+		obj.IPTablesDropBit = ptr.To[int32](DefaultIPTablesDropBit)
 	}
 	if obj.FailSwapOn == nil {
-		obj.FailSwapOn = utilpointer.Bool(true)
+		obj.FailSwapOn = ptr.To(true)
 	}
 	if obj.ContainerLogMaxSize == "" {
 		obj.ContainerLogMaxSize = "10Mi"
 	}
 	if obj.ContainerLogMaxFiles == nil {
-		obj.ContainerLogMaxFiles = utilpointer.Int32(5)
+		obj.ContainerLogMaxFiles = ptr.To[int32](5)
 	}
 	if obj.ContainerLogMaxWorkers == nil {
-		obj.ContainerLogMaxWorkers = utilpointer.Int32(1)
+		obj.ContainerLogMaxWorkers = ptr.To[int32](1)
 	}
 	if obj.ContainerLogMonitorInterval == nil {
 		obj.ContainerLogMonitorInterval = &metav1.Duration{Duration: 10 * time.Second}
@@ -257,28 +257,28 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
 	// Use the Default LoggingConfiguration option
 	logsapi.SetRecommendedLoggingConfiguration(&obj.Logging)
 	if obj.EnableSystemLogHandler == nil {
-		obj.EnableSystemLogHandler = utilpointer.Bool(true)
+		obj.EnableSystemLogHandler = ptr.To(true)
 	}
 	if obj.EnableProfilingHandler == nil {
-		obj.EnableProfilingHandler = utilpointer.Bool(true)
+		obj.EnableProfilingHandler = ptr.To(true)
 	}
 	if obj.EnableDebugFlagsHandler == nil {
-		obj.EnableDebugFlagsHandler = utilpointer.Bool(true)
+		obj.EnableDebugFlagsHandler = ptr.To(true)
 	}
 	if obj.SeccompDefault == nil {
-		obj.SeccompDefault = utilpointer.Bool(false)
+		obj.SeccompDefault = ptr.To(false)
 	}
 	if obj.FailCgroupV1 == nil {
-		obj.FailCgroupV1 = utilpointer.Bool(false)
+		obj.FailCgroupV1 = ptr.To(false)
 	}
 	if obj.MemoryThrottlingFactor == nil {
-		obj.MemoryThrottlingFactor = utilpointer.Float64(DefaultMemoryThrottlingFactor)
+		obj.MemoryThrottlingFactor = ptr.To(DefaultMemoryThrottlingFactor)
 	}
 	if obj.RegisterNode == nil {
-		obj.RegisterNode = utilpointer.Bool(true)
+		obj.RegisterNode = ptr.To(true)
 	}
 	if obj.LocalStorageCapacityIsolation == nil {
-		obj.LocalStorageCapacityIsolation = utilpointer.Bool(true)
+		obj.LocalStorageCapacityIsolation = ptr.To(true)
 	}
 	if obj.ContainerRuntimeEndpoint == "" {
 		obj.ContainerRuntimeEndpoint = "unix:///run/containerd/containerd.sock"