github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-31 15:25:57 +00:00
Code Issues Projects Releases Wiki Activity

use utils/ptr package instead of utils/pointer

Browse Source 
Signed-off-by: sivchari <shibuuuu5@gmail.com>
This commit is contained in:
sivchari 2024-09-17 15:43:35 +09:00
parent 048c8536d6
commit 4eab3cca0a
13 changed files with 332 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/kubelet/apis/config/fuzzer/fuzzer.go
View File

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

68
pkg/kubelet/apis/config/v1beta1/defaults.go
View File

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

526
pkg/kubelet/apis/config/v1beta1/defaults_test.go
View File

@ -30,7 +30,7 @@ import (
"k8s.io/kubernetes/pkg/cluster/ports" "k8s.io/kubernetes/pkg/cluster/ports"
"k8s.io/kubernetes/pkg/kubelet/qos" "k8s.io/kubernetes/pkg/kubelet/qos"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types" kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
utilpointer "k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
func TestSetDefaultsKubeletConfiguration(t *testing.T) { func TestSetDefaultsKubeletConfiguration(t *testing.T) {
@ -44,16 +44,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"empty config", "empty config",
&v1beta1.KubeletConfiguration{}, &v1beta1.KubeletConfiguration{},
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute}, SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0", Address: "0.0.0.0",
Port: ports.KubeletPort, Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -64,25 +64,25 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32(5), RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(50), EventRecordQPS: ptr.To[int32](50),
EventBurst: 100, EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
HealthzPort: utilpointer.Int32(10248), HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute}, NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40, NodeLeaseDurationSeconds: 40,
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute}, ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageMaximumGCAge: metav1.Duration{}, ImageMaximumGCAge: metav1.Duration{},
ImageGCHighThresholdPercent: utilpointer.Int32(85), ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: utilpointer.Int32(80), ImageGCLowThresholdPercent: ptr.To[int32](80),
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -92,27 +92,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute}, RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge, HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32(50), NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(50), KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100, KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true), SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: nil, MaxParallelImagePulls: nil,
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit), IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5), ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -121,21 +121,21 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir, PodLogsDir: DefaultPodLogsDir,
}, },
}, },
{ {
"all negative", "all negative",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(false), EnableServer: ptr.To(false),
StaticPodPath: "", StaticPodPath: "",
SyncFrequency: zeroDuration, SyncFrequency: zeroDuration,
FileCheckFrequency: zeroDuration, FileCheckFrequency: zeroDuration,
@ -154,10 +154,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""}, X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(false), Enabled: ptr.To(false),
CacheTTL: zeroDuration, CacheTTL: zeroDuration,
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook, Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -166,15 +166,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: zeroDuration, CacheUnauthorizedTTL: zeroDuration,
}, },
}, },
RegistryPullQPS: utilpointer.Int32(0), RegistryPullQPS: ptr.To[int32](0),
RegistryBurst: 0, RegistryBurst: 0,
EventRecordQPS: utilpointer.Int32(0), EventRecordQPS: ptr.To[int32](0),
EventBurst: 0, EventBurst: 0,
EnableDebuggingHandlers: utilpointer.Bool(false), EnableDebuggingHandlers: ptr.To(false),
EnableContentionProfiling: false, EnableContentionProfiling: false,
HealthzPort: utilpointer.Int32(0), HealthzPort: ptr.To[int32](0),
HealthzBindAddress: "", HealthzBindAddress: "",
OOMScoreAdj: utilpointer.Int32(0), OOMScoreAdj: ptr.To[int32](0),
ClusterDomain: "", ClusterDomain: "",
ClusterDNS: []string{}, ClusterDNS: []string{},
StreamingConnectionIdleTimeout: zeroDuration, StreamingConnectionIdleTimeout: zeroDuration,
@ -183,13 +183,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 0, NodeLeaseDurationSeconds: 0,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: zeroDuration, ImageMinimumGCAge: zeroDuration,
ImageGCHighThresholdPercent: utilpointer.Int32(0), ImageGCHighThresholdPercent: ptr.To[int32](0),
ImageGCLowThresholdPercent: utilpointer.Int32(0), ImageGCLowThresholdPercent: ptr.To[int32](0),
VolumeStatsAggPeriod: zeroDuration, VolumeStatsAggPeriod: zeroDuration,
KubeletCgroups: "", KubeletCgroups: "",
SystemCgroups: "", SystemCgroups: "",
CgroupRoot: "", CgroupRoot: "",
CgroupsPerQOS: utilpointer.Bool(false), CgroupsPerQOS: ptr.To(false),
CgroupDriver: "", CgroupDriver: "",
CPUManagerPolicy: "", CPUManagerPolicy: "",
CPUManagerPolicyOptions: map[string]string{}, CPUManagerPolicyOptions: map[string]string{},
@ -202,17 +202,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: "", HairpinMode: "",
MaxPods: 0, MaxPods: 0,
PodCIDR: "", PodCIDR: "",
PodPidsLimit: utilpointer.Int64(0), PodPidsLimit: ptr.To[int64](0),
ResolverConfig: utilpointer.String(""), ResolverConfig: ptr.To(""),
RunOnce: false, RunOnce: false,
CPUCFSQuota: utilpointer.Bool(false), CPUCFSQuota: ptr.To(false),
CPUCFSQuotaPeriod: &zeroDuration, CPUCFSQuotaPeriod: &zeroDuration,
NodeStatusMaxImages: utilpointer.Int32(0), NodeStatusMaxImages: ptr.To[int32](0),
MaxOpenFiles: 0, MaxOpenFiles: 0,
ContentType: "", ContentType: "",
KubeAPIQPS: utilpointer.Int32(0), KubeAPIQPS: ptr.To[int32](0),
KubeAPIBurst: 0, KubeAPIBurst: 0,
SerializeImagePulls: utilpointer.Bool(false), SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: nil, MaxParallelImagePulls: nil,
EvictionHard: map[string]string{}, EvictionHard: map[string]string{},
EvictionSoft: map[string]string{}, EvictionSoft: map[string]string{},
@ -221,17 +221,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EvictionMaxPodGracePeriod: 0, EvictionMaxPodGracePeriod: 0,
EvictionMinimumReclaim: map[string]string{}, EvictionMinimumReclaim: map[string]string{},
PodsPerCore: 0, PodsPerCore: 0,
EnableControllerAttachDetach: utilpointer.Bool(false), EnableControllerAttachDetach: ptr.To(false),
ProtectKernelDefaults: false, ProtectKernelDefaults: false,
MakeIPTablesUtilChains: utilpointer.Bool(false), MakeIPTablesUtilChains: ptr.To(false),
IPTablesMasqueradeBit: utilpointer.Int32(0), IPTablesMasqueradeBit: ptr.To[int32](0),
IPTablesDropBit: utilpointer.Int32(0), IPTablesDropBit: ptr.To[int32](0),
FeatureGates: map[string]bool{}, FeatureGates: map[string]bool{},
FailSwapOn: utilpointer.Bool(false), FailSwapOn: ptr.To(false),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""}, MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""},
ContainerLogMaxSize: "", ContainerLogMaxSize: "",
ContainerLogMaxFiles: utilpointer.Int32(0), ContainerLogMaxFiles: ptr.To[int32](0),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
SystemReserved: map[string]string{}, SystemReserved: map[string]string{},
@ -249,21 +249,21 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "", Format: "",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(false), EnableSystemLogHandler: ptr.To(false),
ShutdownGracePeriod: zeroDuration, ShutdownGracePeriod: zeroDuration,
ShutdownGracePeriodCriticalPods: zeroDuration, ShutdownGracePeriodCriticalPods: zeroDuration,
ReservedMemory: []v1beta1.MemoryReservation{}, ReservedMemory: []v1beta1.MemoryReservation{},
EnableProfilingHandler: utilpointer.Bool(false), EnableProfilingHandler: ptr.To(false),
EnableDebugFlagsHandler: utilpointer.Bool(false), EnableDebugFlagsHandler: ptr.To(false),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: ptr.To[float64](0),
RegisterNode: utilpointer.Bool(false), RegisterNode: ptr.To(false),
LocalStorageCapacityIsolation: utilpointer.Bool(false), LocalStorageCapacityIsolation: ptr.To(false),
PodLogsDir: "", PodLogsDir: "",
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(false), EnableServer: ptr.To(false),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute}, SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
@ -274,10 +274,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""}, X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(false), Enabled: ptr.To(false),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook, Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -286,14 +286,14 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32(0), RegistryPullQPS: ptr.To[int32](0),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(0), EventRecordQPS: ptr.To[int32](0),
EventBurst: 100, EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(false), EnableDebuggingHandlers: ptr.To(false),
HealthzPort: utilpointer.Int32(0), HealthzPort: ptr.To[int32](0),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(0), OOMScoreAdj: ptr.To[int32](0),
ClusterDNS: []string{}, ClusterDNS: []string{},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
@ -301,10 +301,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 40, NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute}, ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32(0), ImageGCHighThresholdPercent: ptr.To[int32](0),
ImageGCLowThresholdPercent: utilpointer.Int32(0), ImageGCLowThresholdPercent: ptr.To[int32](0),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(false), CgroupsPerQOS: ptr.To(false),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerPolicyOptions: map[string]string{}, CPUManagerPolicyOptions: map[string]string{},
@ -316,32 +316,32 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute}, RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge, HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(0), PodPidsLimit: ptr.To[int64](0),
ResolverConfig: utilpointer.String(""), ResolverConfig: ptr.To(""),
CPUCFSQuota: utilpointer.Bool(false), CPUCFSQuota: ptr.To(false),
CPUCFSQuotaPeriod: &zeroDuration, CPUCFSQuotaPeriod: &zeroDuration,
NodeStatusMaxImages: utilpointer.Int32(0), NodeStatusMaxImages: ptr.To[int32](0),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(0), KubeAPIQPS: ptr.To[int32](0),
KubeAPIBurst: 100, KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(false), SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: nil, MaxParallelImagePulls: nil,
EvictionHard: map[string]string{}, EvictionHard: map[string]string{},
EvictionSoft: map[string]string{}, EvictionSoft: map[string]string{},
EvictionSoftGracePeriod: map[string]string{}, EvictionSoftGracePeriod: map[string]string{},
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EvictionMinimumReclaim: map[string]string{}, EvictionMinimumReclaim: map[string]string{},
EnableControllerAttachDetach: utilpointer.Bool(false), EnableControllerAttachDetach: ptr.To(false),
MakeIPTablesUtilChains: utilpointer.Bool(false), MakeIPTablesUtilChains: ptr.To(false),
IPTablesMasqueradeBit: utilpointer.Int32(0), IPTablesMasqueradeBit: ptr.To[int32](0),
IPTablesDropBit: utilpointer.Int32(0), IPTablesDropBit: ptr.To[int32](0),
FeatureGates: map[string]bool{}, FeatureGates: map[string]bool{},
FailSwapOn: utilpointer.Bool(false), FailSwapOn: ptr.To(false),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""}, MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""},
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(0), ContainerLogMaxFiles: ptr.To[int32](0),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
SystemReserved: map[string]string{}, SystemReserved: map[string]string{},
@ -353,22 +353,22 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(false), EnableSystemLogHandler: ptr.To(false),
ReservedMemory: []v1beta1.MemoryReservation{}, ReservedMemory: []v1beta1.MemoryReservation{},
EnableProfilingHandler: utilpointer.Bool(false), EnableProfilingHandler: ptr.To(false),
EnableDebugFlagsHandler: utilpointer.Bool(false), EnableDebugFlagsHandler: ptr.To(false),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: ptr.To[float64](0),
RegisterNode: utilpointer.Bool(false), RegisterNode: ptr.To(false),
LocalStorageCapacityIsolation: utilpointer.Bool(false), LocalStorageCapacityIsolation: ptr.To(false),
PodLogsDir: DefaultPodLogsDir, PodLogsDir: DefaultPodLogsDir,
}, },
}, },
{ {
"all positive", "all positive",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
StaticPodPath: "static/pod/path", StaticPodPath: "static/pod/path",
SyncFrequency: metav1.Duration{Duration: 60 * time.Second}, SyncFrequency: metav1.Duration{Duration: 60 * time.Second},
FileCheckFrequency: metav1.Duration{Duration: 60 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 60 * time.Second},
@ -387,10 +387,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"}, X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second}, CacheTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(true)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow, Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -399,15 +399,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32(1), RegistryPullQPS: ptr.To[int32](1),
RegistryBurst: 1, RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1), EventRecordQPS: ptr.To[int32](1),
EventBurst: 1, EventBurst: 1,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
EnableContentionProfiling: true, EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1), HealthzPort: ptr.To[int32](1),
HealthzBindAddress: "127.0.0.2", HealthzBindAddress: "127.0.0.2",
OOMScoreAdj: utilpointer.Int32(1), OOMScoreAdj: ptr.To[int32](1),
ClusterDomain: "cluster-domain", ClusterDomain: "cluster-domain",
ClusterDNS: []string{"192.168.1.3"}, ClusterDNS: []string{"192.168.1.3"},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second},
@ -416,13 +416,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 1, NodeLeaseDurationSeconds: 1,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second}, ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second},
ImageGCHighThresholdPercent: utilpointer.Int32(1), ImageGCHighThresholdPercent: ptr.To[int32](1),
ImageGCLowThresholdPercent: utilpointer.Int32(1), ImageGCLowThresholdPercent: ptr.To[int32](1),
VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second}, VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second},
KubeletCgroups: "kubelet-cgroup", KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup", SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup", CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "systemd", CgroupDriver: "systemd",
CPUManagerPolicy: "cpu-manager-policy", CPUManagerPolicy: "cpu-manager-policy",
CPUManagerPolicyOptions: map[string]string{"key": "value"}, CPUManagerPolicyOptions: map[string]string{"key": "value"},
@ -435,18 +435,18 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: v1beta1.HairpinVeth, HairpinMode: v1beta1.HairpinVeth,
MaxPods: 1, MaxPods: 1,
PodCIDR: "192.168.1.0/24", PodCIDR: "192.168.1.0/24",
PodPidsLimit: utilpointer.Int64(1), PodPidsLimit: ptr.To[int64](1),
ResolverConfig: utilpointer.String("resolver-config"), ResolverConfig: ptr.To("resolver-config"),
RunOnce: true, RunOnce: true,
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second},
NodeStatusMaxImages: utilpointer.Int32(1), NodeStatusMaxImages: ptr.To[int32](1),
MaxOpenFiles: 1, MaxOpenFiles: 1,
ContentType: "application/protobuf", ContentType: "application/protobuf",
KubeAPIQPS: utilpointer.Int32(1), KubeAPIQPS: ptr.To[int32](1),
KubeAPIBurst: 1, KubeAPIBurst: 1,
SerializeImagePulls: utilpointer.Bool(true), SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: utilpointer.Int32(5), MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: map[string]string{ EvictionHard: map[string]string{
"memory.available": "1Mi", "memory.available": "1Mi",
"nodefs.available": "1%", "nodefs.available": "1%",
@ -468,16 +468,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"imagefs.available": "1Gi", "imagefs.available": "1Gi",
}, },
PodsPerCore: 1, PodsPerCore: 1,
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
ProtectKernelDefaults: true, ProtectKernelDefaults: true,
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32(1), IPTablesMasqueradeBit: ptr.To[int32](1),
IPTablesDropBit: utilpointer.Int32(1), IPTablesDropBit: ptr.To[int32](1),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"}, MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"},
ContainerLogMaxSize: "1Mi", ContainerLogMaxSize: "1Mi",
ContainerLogMaxFiles: utilpointer.Int32(1), ContainerLogMaxFiles: ptr.To[int32](1),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy,
SystemReserved: map[string]string{ SystemReserved: map[string]string{
@ -499,7 +499,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "json", Format: "json",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
ShutdownGracePeriod: metav1.Duration{Duration: 60 * time.Second}, ShutdownGracePeriod: metav1.Duration{Duration: 60 * time.Second},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second}, ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second},
ReservedMemory: []v1beta1.MemoryReservation{ ReservedMemory: []v1beta1.MemoryReservation{
@ -508,17 +508,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")}, Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")},
}, },
}, },
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(true), SeccompDefault: ptr.To(true),
FailCgroupV1: utilpointer.Bool(true), FailCgroupV1: ptr.To(true),
MemoryThrottlingFactor: utilpointer.Float64(1), MemoryThrottlingFactor: ptr.To[float64](1),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: "/custom/path", PodLogsDir: "/custom/path",
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
StaticPodPath: "static/pod/path", StaticPodPath: "static/pod/path",
SyncFrequency: metav1.Duration{Duration: 60 * time.Second}, SyncFrequency: metav1.Duration{Duration: 60 * time.Second},
FileCheckFrequency: metav1.Duration{Duration: 60 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 60 * time.Second},
@ -537,10 +537,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"}, X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second}, CacheTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(true)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow, Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -549,15 +549,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32(1), RegistryPullQPS: ptr.To[int32](1),
RegistryBurst: 1, RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1), EventRecordQPS: ptr.To[int32](1),
EventBurst: 1, EventBurst: 1,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
EnableContentionProfiling: true, EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1), HealthzPort: ptr.To[int32](1),
HealthzBindAddress: "127.0.0.2", HealthzBindAddress: "127.0.0.2",
OOMScoreAdj: utilpointer.Int32(1), OOMScoreAdj: ptr.To[int32](1),
ClusterDomain: "cluster-domain", ClusterDomain: "cluster-domain",
ClusterDNS: []string{"192.168.1.3"}, ClusterDNS: []string{"192.168.1.3"},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second},
@ -566,13 +566,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 1, NodeLeaseDurationSeconds: 1,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second}, ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second},
ImageGCHighThresholdPercent: utilpointer.Int32(1), ImageGCHighThresholdPercent: ptr.To[int32](1),
ImageGCLowThresholdPercent: utilpointer.Int32(1), ImageGCLowThresholdPercent: ptr.To[int32](1),
VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second}, VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second},
KubeletCgroups: "kubelet-cgroup", KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup", SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup", CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "systemd", CgroupDriver: "systemd",
CPUManagerPolicy: "cpu-manager-policy", CPUManagerPolicy: "cpu-manager-policy",
CPUManagerPolicyOptions: map[string]string{"key": "value"}, CPUManagerPolicyOptions: map[string]string{"key": "value"},
@ -585,18 +585,18 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: v1beta1.HairpinVeth, HairpinMode: v1beta1.HairpinVeth,
MaxPods: 1, MaxPods: 1,
PodCIDR: "192.168.1.0/24", PodCIDR: "192.168.1.0/24",
PodPidsLimit: utilpointer.Int64(1), PodPidsLimit: ptr.To[int64](1),
ResolverConfig: utilpointer.String("resolver-config"), ResolverConfig: ptr.To("resolver-config"),
RunOnce: true, RunOnce: true,
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second},
NodeStatusMaxImages: utilpointer.Int32(1), NodeStatusMaxImages: ptr.To[int32](1),
MaxOpenFiles: 1, MaxOpenFiles: 1,
ContentType: "application/protobuf", ContentType: "application/protobuf",
KubeAPIQPS: utilpointer.Int32(1), KubeAPIQPS: ptr.To[int32](1),
KubeAPIBurst: 1, KubeAPIBurst: 1,
SerializeImagePulls: utilpointer.Bool(true), SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: utilpointer.Int32Ptr(5), MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: map[string]string{ EvictionHard: map[string]string{
"memory.available": "1Mi", "memory.available": "1Mi",
"nodefs.available": "1%", "nodefs.available": "1%",
@ -618,16 +618,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"imagefs.available": "1Gi", "imagefs.available": "1Gi",
}, },
PodsPerCore: 1, PodsPerCore: 1,
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
ProtectKernelDefaults: true, ProtectKernelDefaults: true,
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32(1), IPTablesMasqueradeBit: ptr.To[int32](1),
IPTablesDropBit: utilpointer.Int32(1), IPTablesDropBit: ptr.To[int32](1),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"}, MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"},
ContainerLogMaxSize: "1Mi", ContainerLogMaxSize: "1Mi",
ContainerLogMaxFiles: utilpointer.Int32(1), ContainerLogMaxFiles: ptr.To[int32](1),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy,
SystemReserved: map[string]string{ SystemReserved: map[string]string{
@ -649,7 +649,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "json", Format: "json",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
ShutdownGracePeriod: metav1.Duration{Duration: 60 * time.Second}, ShutdownGracePeriod: metav1.Duration{Duration: 60 * time.Second},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second}, ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second},
ReservedMemory: []v1beta1.MemoryReservation{ ReservedMemory: []v1beta1.MemoryReservation{
@ -658,13 +658,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")}, Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")},
}, },
}, },
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(true), SeccompDefault: ptr.To(true),
FailCgroupV1: utilpointer.Bool(true), FailCgroupV1: ptr.To(true),
MemoryThrottlingFactor: utilpointer.Float64(1), MemoryThrottlingFactor: ptr.To[float64](1),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: "/custom/path", PodLogsDir: "/custom/path",
}, },
}, },
@ -674,16 +674,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute},
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute}, SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0", Address: "0.0.0.0",
Port: ports.KubeletPort, Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -694,24 +694,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32(5), RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(50), EventRecordQPS: ptr.To[int32](50),
EventBurst: 100, EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
HealthzPort: utilpointer.Int32(10248), HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute},
NodeStatusReportFrequency: metav1.Duration{Duration: 1 * time.Minute}, NodeStatusReportFrequency: metav1.Duration{Duration: 1 * time.Minute},
NodeLeaseDurationSeconds: 40, NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute}, ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32(85), ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: utilpointer.Int32(80), ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -721,27 +721,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute}, RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge, HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32(50), NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(50), KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100, KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true), SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: nil, MaxParallelImagePulls: nil,
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit), IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5), ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -750,33 +750,33 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir, PodLogsDir: DefaultPodLogsDir,
}, },
}, },
{ {
"SerializeImagePull defaults to false when MaxParallelImagePulls is larger than 1", "SerializeImagePull defaults to false when MaxParallelImagePulls is larger than 1",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
MaxParallelImagePulls: utilpointer.Int32(5), MaxParallelImagePulls: ptr.To[int32](5),
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute}, SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0", Address: "0.0.0.0",
Port: ports.KubeletPort, Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -787,24 +787,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32Ptr(5), RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(50), EventRecordQPS: ptr.To[int32](50),
EventBurst: 100, EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
HealthzPort: utilpointer.Int32Ptr(10248), HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute}, NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40, NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute}, ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32Ptr(85), ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80), ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -814,27 +814,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute}, RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge, HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50), NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(50), KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100, KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(false), SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: utilpointer.Int32(5), MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit), IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5), ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -843,33 +843,33 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir, PodLogsDir: DefaultPodLogsDir,
}, },
}, },
{ {
"SerializeImagePull defaults to true when MaxParallelImagePulls is set to 1", "SerializeImagePull defaults to true when MaxParallelImagePulls is set to 1",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
MaxParallelImagePulls: utilpointer.Int32(1), MaxParallelImagePulls: ptr.To[int32](1),
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true), EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute}, SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second}, HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0", Address: "0.0.0.0",
Port: ports.KubeletPort, Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{ Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true), Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -880,24 +880,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second}, CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
}, },
}, },
RegistryPullQPS: utilpointer.Int32Ptr(5), RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(50), EventRecordQPS: ptr.To[int32](50),
EventBurst: 100, EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true), EnableDebuggingHandlers: ptr.To(true),
HealthzPort: utilpointer.Int32Ptr(10248), HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour}, StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second}, NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute}, NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40, NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock", ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute}, ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32Ptr(85), ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80), ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true), CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -907,27 +907,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute}, RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge, HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true), CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50), NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(50), KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100, KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true), SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: utilpointer.Int32(1), MaxParallelImagePulls: ptr.To[int32](1),
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true), EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: utilpointer.Bool(true), MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit), IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true), FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5), ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: utilpointer.Int32(1), ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second}, ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -936,14 +936,14 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true}, FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
}, },
EnableSystemLogHandler: utilpointer.Bool(true), EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: utilpointer.Bool(true), EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: ptr.To(false),
FailCgroupV1: utilpointer.Bool(false), FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true), RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true), LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir, PodLogsDir: DefaultPodLogsDir,
}, },
}, },

12
pkg/kubelet/apis/config/validation/validation_test.go
View File

@ -29,7 +29,7 @@ import (
kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config" kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config"
"k8s.io/kubernetes/pkg/kubelet/apis/config/validation" "k8s.io/kubernetes/pkg/kubelet/apis/config/validation"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types" kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
utilpointer "k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
var ( var (
@ -66,7 +66,7 @@ var (
TopologyManagerPolicy: kubeletconfig.SingleNumaNodeTopologyManagerPolicy, TopologyManagerPolicy: kubeletconfig.SingleNumaNodeTopologyManagerPolicy,
ShutdownGracePeriod: metav1.Duration{Duration: 30 * time.Second}, ShutdownGracePeriod: metav1.Duration{Duration: 30 * time.Second},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 10 * time.Second}, ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 10 * time.Second},
MemoryThrottlingFactor: utilpointer.Float64(0.9), MemoryThrottlingFactor: ptr.To(0.9),
FeatureGates: map[string]bool{ FeatureGates: map[string]bool{
"CustomCPUCFSQuotaPeriod": true, "CustomCPUCFSQuotaPeriod": true,
"GracefulNodeShutdown": true, "GracefulNodeShutdown": true,
@ -278,14 +278,14 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, { }, {
name: "invalid MaxParallelImagePulls", name: "invalid MaxParallelImagePulls",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration { configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(0) conf.MaxParallelImagePulls = ptr.To[int32](0)
return conf return conf
}, },
errMsg: "invalid configuration: maxParallelImagePulls 0 must be a positive number", errMsg: "invalid configuration: maxParallelImagePulls 0 must be a positive number",
}, { }, {
name: "invalid MaxParallelImagePulls and SerializeImagePulls combination", name: "invalid MaxParallelImagePulls and SerializeImagePulls combination",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration { configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(3) conf.MaxParallelImagePulls = ptr.To[int32](3)
conf.SerializeImagePulls = true conf.SerializeImagePulls = true
return conf return conf
}, },
@ -293,7 +293,7 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, { }, {
name: "valid MaxParallelImagePulls and SerializeImagePulls combination", name: "valid MaxParallelImagePulls and SerializeImagePulls combination",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration { configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(1) conf.MaxParallelImagePulls = ptr.To[int32](1)
conf.SerializeImagePulls = true conf.SerializeImagePulls = true
return conf return conf
}, },
@ -454,7 +454,7 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, { }, {
name: "invalid MemoryThrottlingFactor", name: "invalid MemoryThrottlingFactor",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration { configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MemoryThrottlingFactor = utilpointer.Float64(1.1) conf.MemoryThrottlingFactor = ptr.To(1.1)
return conf return conf
}, },
errMsg: "invalid configuration: memoryThrottlingFactor 1.1 must be greater than 0 and less than or equal to 1.0", errMsg: "invalid configuration: memoryThrottlingFactor 1.1 must be greater than 0 and less than or equal to 1.0",

4
pkg/kubelet/cadvisor/cadvisor_linux.go
View File

@ -39,7 +39,7 @@ import (
"github.com/google/cadvisor/manager" "github.com/google/cadvisor/manager"
"github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/utils/sysfs"
"k8s.io/klog/v2" "k8s.io/klog/v2"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
type cadvisorClient struct { type cadvisorClient struct {
@ -98,7 +98,7 @@ func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, cgroupRoots [
duration := maxHousekeepingInterval duration := maxHousekeepingInterval
housekeepingConfig := manager.HousekeepingConfig{ housekeepingConfig := manager.HousekeepingConfig{
Interval: &duration, Interval: &duration,
AllowDynamic: pointer.Bool(allowDynamicHousekeeping), AllowDynamic: ptr.To(allowDynamicHousekeeping),
} }
// Create the cAdvisor container manager. // Create the cAdvisor container manager.

8
pkg/kubelet/kubelet_test.go
View File

@ -106,7 +106,7 @@ import (
"k8s.io/kubernetes/pkg/volume/util/subpath" "k8s.io/kubernetes/pkg/volume/util/subpath"
"k8s.io/utils/clock" "k8s.io/utils/clock"
testingclock "k8s.io/utils/clock/testing" testingclock "k8s.io/utils/clock/testing"
utilpointer "k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
func init() { func init() {
@ -3043,7 +3043,7 @@ func TestNewMainKubeletStandAlone(t *testing.T) {
ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy,
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: 5, ContainerLogMaxFiles: 5,
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: ptr.To[float64](0),
} }
var prober volume.DynamicPluginProber var prober volume.DynamicPluginProber
tp := noopoteltrace.NewTracerProvider() tp := noopoteltrace.NewTracerProvider()
@ -3166,7 +3166,7 @@ func TestSyncPodSpans(t *testing.T) {
ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy,
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: 5, ContainerLogMaxFiles: 5,
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: ptr.To[float64](0),
} }
exp := tracetest.NewInMemoryExporter() exp := tracetest.NewInMemoryExporter()
@ -3231,7 +3231,7 @@ func TestSyncPodSpans(t *testing.T) {
ImagePullPolicy: v1.PullAlways, ImagePullPolicy: v1.PullAlways,
}, },
}, },
EnableServiceLinks: utilpointer.Bool(false), EnableServiceLinks: ptr.To(false),
}) })
_, err = kubelet.SyncPod(context.Background(), kubetypes.SyncPodCreate, pod, nil, &kubecontainer.PodStatus{}) _, err = kubelet.SyncPod(context.Background(), kubetypes.SyncPodCreate, pod, nil, &kubecontainer.PodStatus{})

6
pkg/kubelet/kuberuntime/fake_kuberuntime_manager.go
View File

@ -38,7 +38,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/lifecycle" "k8s.io/kubernetes/pkg/kubelet/lifecycle"
"k8s.io/kubernetes/pkg/kubelet/logs" "k8s.io/kubernetes/pkg/kubelet/logs"
proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results" proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
utilpointer "k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
const ( const (
@ -134,8 +134,8 @@ func newFakeKubeRuntimeManager(runtimeService internalapi.RuntimeService, imageS
kubeRuntimeManager, kubeRuntimeManager,
flowcontrol.NewBackOff(time.Second, 300*time.Second), flowcontrol.NewBackOff(time.Second, 300*time.Second),
false, false,
utilpointer.Int32Ptr(0), // No limit on max parallel image pulls, ptr.To[int32](0), // No limit on max parallel image pulls,
0, // Disable image pull throttling by setting QPS to 0, 0, // Disable image pull throttling by setting QPS to 0,
0, 0,
&fakePodPullingTimeRecorder{}, &fakePodPullingTimeRecorder{},
) )

6
pkg/kubelet/kuberuntime/kuberuntime_sandbox_test.go
View File

@ -34,7 +34,7 @@ import (
containertest "k8s.io/kubernetes/pkg/kubelet/container/testing" containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
"k8s.io/kubernetes/pkg/kubelet/runtimeclass" "k8s.io/kubernetes/pkg/kubelet/runtimeclass"
rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing" rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
const testPodLogsDirectory = "/var/log/pods" const testPodLogsDirectory = "/var/log/pods"
@ -153,8 +153,8 @@ func TestCreatePodSandbox_RuntimeClass(t *testing.T) {
expectError bool expectError bool
}{ }{
"unspecified RuntimeClass": {rcn: nil, expectedHandler: ""}, "unspecified RuntimeClass": {rcn: nil, expectedHandler: ""},
"valid RuntimeClass": {rcn: pointer.String(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler}, "valid RuntimeClass": {rcn: ptr.To(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler},
"missing RuntimeClass": {rcn: pointer.String("phantom"), expectError: true}, "missing RuntimeClass": {rcn: ptr.To("phantom"), expectError: true},
} }
for name, test := range tests { for name, test := range tests {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {

4
pkg/kubelet/pod/mirror_client_test.go
View File

@ -29,7 +29,7 @@ import (
"k8s.io/client-go/kubernetes/fake" "k8s.io/client-go/kubernetes/fake"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container" kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types" kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
func TestParsePodFullName(t *testing.T) { func TestParsePodFullName(t *testing.T) {
@ -137,7 +137,7 @@ func TestCreateMirrorPod(t *testing.T) {
Kind: "Node", Kind: "Node",
Name: testNodeName, Name: testNodeName,
UID: testNodeUID, UID: testNodeUID,
Controller: pointer.Bool(true), Controller: ptr.To(true),
} }
assert.Equal(t, expectedOwnerRef, createdPod.OwnerReferences[0]) assert.Equal(t, expectedOwnerRef, createdPod.OwnerReferences[0])
}) })

4
pkg/kubelet/prober/scale_test.go
View File

@ -38,7 +38,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/status" "k8s.io/kubernetes/pkg/kubelet/status"
statustest "k8s.io/kubernetes/pkg/kubelet/status/testing" statustest "k8s.io/kubernetes/pkg/kubelet/status/testing"
kubeletutil "k8s.io/kubernetes/pkg/kubelet/util" kubeletutil "k8s.io/kubernetes/pkg/kubelet/util"
utilpointer "k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
// TCP sockets goes through a TIME-WAIT state (default 60 sec) before being freed, // TCP sockets goes through a TIME-WAIT state (default 60 sec) before being freed,
@ -136,7 +136,7 @@ func TestTCPPortExhaustion(t *testing.T) {
StartedAt: metav1.Now(), StartedAt: metav1.Now(),
}, },
}, },
Started: utilpointer.Bool(true), Started: ptr.To(true),
}) })
} }
podManager.AddPod(&pod) podManager.AddPod(&pod)

10
pkg/kubelet/runtimeclass/runtimeclass_manager_test.go
View File

@ -24,7 +24,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/runtimeclass" "k8s.io/kubernetes/pkg/kubelet/runtimeclass"
rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing" rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
func TestLookupRuntimeHandler(t *testing.T) { func TestLookupRuntimeHandler(t *testing.T) {
@ -33,10 +33,10 @@ func TestLookupRuntimeHandler(t *testing.T) {
expected string expected string
expectError bool expectError bool
}{ }{
{rcn: pointer.String(""), expected: ""}, {rcn: ptr.To(""), expected: ""},
{rcn: pointer.String(rctest.EmptyRuntimeClass), expected: ""}, {rcn: ptr.To(rctest.EmptyRuntimeClass), expected: ""},
{rcn: pointer.String(rctest.SandboxRuntimeClass), expected: "kata-containers"}, {rcn: ptr.To(rctest.SandboxRuntimeClass), expected: "kata-containers"},
{rcn: pointer.String("phantom"), expectError: true}, {rcn: ptr.To("phantom"), expectError: true},
} }
manager := runtimeclass.NewManager(rctest.NewPopulatedClient()) manager := runtimeclass.NewManager(rctest.NewPopulatedClient())

6
pkg/kubelet/server/server_test.go
View File

@ -50,7 +50,7 @@ import (
runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1"
statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
api "k8s.io/kubernetes/pkg/apis/core" api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
// Do some initialization to decode the query parameters correctly. // Do some initialization to decode the query parameters correctly.
utilfeature "k8s.io/apiserver/pkg/util/feature" utilfeature "k8s.io/apiserver/pkg/util/feature"
@ -802,8 +802,8 @@ func TestContainerLogs(t *testing.T) {
podLogOption *v1.PodLogOptions podLogOption *v1.PodLogOptions
}{ }{
"without tail": {"", &v1.PodLogOptions{}}, "without tail": {"", &v1.PodLogOptions{}},
"with tail": {"?tailLines=5", &v1.PodLogOptions{TailLines: pointer.Int64(5)}}, "with tail": {"?tailLines=5", &v1.PodLogOptions{TailLines: ptr.To[int64](5)}},
"with legacy tail": {"?tail=5", &v1.PodLogOptions{TailLines: pointer.Int64(5)}}, "with legacy tail": {"?tail=5", &v1.PodLogOptions{TailLines: ptr.To[int64](5)}},
"with tail all": {"?tail=all", &v1.PodLogOptions{}}, "with tail all": {"?tail=all", &v1.PodLogOptions{}},
"with follow": {"?follow=1", &v1.PodLogOptions{Follow: true}}, "with follow": {"?follow=1", &v1.PodLogOptions{Follow: true}},
} }

6
pkg/kubelet/status/generate_test.go
View File

@ -26,7 +26,7 @@ import (
v1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1"
runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container" kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
"k8s.io/utils/pointer" "k8s.io/utils/ptr"
) )
var ( var (
@ -648,13 +648,13 @@ func getNotReadyStatus(cName string) v1.ContainerStatus {
func getStartedStatus(cName string) v1.ContainerStatus { func getStartedStatus(cName string) v1.ContainerStatus {
return v1.ContainerStatus{ return v1.ContainerStatus{
Name: cName, Name: cName,
Started: pointer.Bool(true), Started: ptr.To(true),
} }
} }
func getNotStartedStatus(cName string) v1.ContainerStatus { func getNotStartedStatus(cName string) v1.ContainerStatus {
return v1.ContainerStatus{ return v1.ContainerStatus{
Name: cName, Name: cName,
Started: pointer.Bool(false), Started: ptr.To(false),
} }
} }