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/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
},
}

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/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"

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/kubelet/qos"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
utilpointer "k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
func TestSetDefaultsKubeletConfiguration(t *testing.T) {
@ -44,16 +44,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"empty config",
&v1beta1.KubeletConfiguration{},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0",
Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
},
},
@ -64,25 +64,25 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32(5),
RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(50),
EventRecordQPS: ptr.To[int32](50),
EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32(10248),
EnableDebuggingHandlers: ptr.To(true),
HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(int32(qos.KubeletOOMScoreAdj)),
OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40,
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageMaximumGCAge: metav1.Duration{},
ImageGCHighThresholdPercent: utilpointer.Int32(85),
ImageGCLowThresholdPercent: utilpointer.Int32(80),
ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: ptr.To[int32](80),
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -92,27 +92,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true),
PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32(50),
NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(50),
KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true),
SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: nil,
EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -121,21 +121,21 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir,
},
},
{
"all negative",
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(false),
EnableServer: ptr.To(false),
StaticPodPath: "",
SyncFrequency: zeroDuration,
FileCheckFrequency: zeroDuration,
@ -154,10 +154,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Authentication: v1beta1.KubeletAuthentication{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(false),
Enabled: ptr.To(false),
CacheTTL: zeroDuration,
},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
},
Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -166,15 +166,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: zeroDuration,
},
},
RegistryPullQPS: utilpointer.Int32(0),
RegistryPullQPS: ptr.To[int32](0),
RegistryBurst: 0,
EventRecordQPS: utilpointer.Int32(0),
EventRecordQPS: ptr.To[int32](0),
EventBurst: 0,
EnableDebuggingHandlers: utilpointer.Bool(false),
EnableDebuggingHandlers: ptr.To(false),
EnableContentionProfiling: false,
HealthzPort: utilpointer.Int32(0),
HealthzPort: ptr.To[int32](0),
HealthzBindAddress: "",
OOMScoreAdj: utilpointer.Int32(0),
OOMScoreAdj: ptr.To[int32](0),
ClusterDomain: "",
ClusterDNS: []string{},
StreamingConnectionIdleTimeout: zeroDuration,
@ -183,13 +183,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 0,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: zeroDuration,
ImageGCHighThresholdPercent: utilpointer.Int32(0),
ImageGCLowThresholdPercent: utilpointer.Int32(0),
ImageGCHighThresholdPercent: ptr.To[int32](0),
ImageGCLowThresholdPercent: ptr.To[int32](0),
VolumeStatsAggPeriod: zeroDuration,
KubeletCgroups: "",
SystemCgroups: "",
CgroupRoot: "",
CgroupsPerQOS: utilpointer.Bool(false),
CgroupsPerQOS: ptr.To(false),
CgroupDriver: "",
CPUManagerPolicy: "",
CPUManagerPolicyOptions: map[string]string{},
@ -202,17 +202,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: "",
MaxPods: 0,
PodCIDR: "",
PodPidsLimit: utilpointer.Int64(0),
ResolverConfig: utilpointer.String(""),
PodPidsLimit: ptr.To[int64](0),
ResolverConfig: ptr.To(""),
RunOnce: false,
CPUCFSQuota: utilpointer.Bool(false),
CPUCFSQuota: ptr.To(false),
CPUCFSQuotaPeriod: &zeroDuration,
NodeStatusMaxImages: utilpointer.Int32(0),
NodeStatusMaxImages: ptr.To[int32](0),
MaxOpenFiles: 0,
ContentType: "",
KubeAPIQPS: utilpointer.Int32(0),
KubeAPIQPS: ptr.To[int32](0),
KubeAPIBurst: 0,
SerializeImagePulls: utilpointer.Bool(false),
SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: nil,
EvictionHard: map[string]string{},
EvictionSoft: map[string]string{},
@ -221,17 +221,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EvictionMaxPodGracePeriod: 0,
EvictionMinimumReclaim: map[string]string{},
PodsPerCore: 0,
EnableControllerAttachDetach: utilpointer.Bool(false),
EnableControllerAttachDetach: ptr.To(false),
ProtectKernelDefaults: false,
MakeIPTablesUtilChains: utilpointer.Bool(false),
IPTablesMasqueradeBit: utilpointer.Int32(0),
IPTablesDropBit: utilpointer.Int32(0),
MakeIPTablesUtilChains: ptr.To(false),
IPTablesMasqueradeBit: ptr.To[int32](0),
IPTablesDropBit: ptr.To[int32](0),
FeatureGates: map[string]bool{},
FailSwapOn: utilpointer.Bool(false),
FailSwapOn: ptr.To(false),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""},
ContainerLogMaxSize: "",
ContainerLogMaxFiles: utilpointer.Int32(0),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](0),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
SystemReserved: map[string]string{},
@ -249,21 +249,21 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(false),
EnableSystemLogHandler: ptr.To(false),
ShutdownGracePeriod: zeroDuration,
ShutdownGracePeriodCriticalPods: zeroDuration,
ReservedMemory: []v1beta1.MemoryReservation{},
EnableProfilingHandler: utilpointer.Bool(false),
EnableDebugFlagsHandler: utilpointer.Bool(false),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(0),
RegisterNode: utilpointer.Bool(false),
LocalStorageCapacityIsolation: utilpointer.Bool(false),
EnableProfilingHandler: ptr.To(false),
EnableDebugFlagsHandler: ptr.To(false),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To[float64](0),
RegisterNode: ptr.To(false),
LocalStorageCapacityIsolation: ptr.To(false),
PodLogsDir: "",
},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(false),
EnableServer: ptr.To(false),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: 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{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: ""},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(false),
Enabled: ptr.To(false),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
},
Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -286,14 +286,14 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32(0),
RegistryPullQPS: ptr.To[int32](0),
RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(0),
EventRecordQPS: ptr.To[int32](0),
EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(false),
HealthzPort: utilpointer.Int32(0),
EnableDebuggingHandlers: ptr.To(false),
HealthzPort: ptr.To[int32](0),
HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(0),
OOMScoreAdj: ptr.To[int32](0),
ClusterDNS: []string{},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
@ -301,10 +301,10 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32(0),
ImageGCLowThresholdPercent: utilpointer.Int32(0),
ImageGCHighThresholdPercent: ptr.To[int32](0),
ImageGCLowThresholdPercent: ptr.To[int32](0),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(false),
CgroupsPerQOS: ptr.To(false),
CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none",
CPUManagerPolicyOptions: map[string]string{},
@ -316,32 +316,32 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110,
PodPidsLimit: utilpointer.Int64(0),
ResolverConfig: utilpointer.String(""),
CPUCFSQuota: utilpointer.Bool(false),
PodPidsLimit: ptr.To[int64](0),
ResolverConfig: ptr.To(""),
CPUCFSQuota: ptr.To(false),
CPUCFSQuotaPeriod: &zeroDuration,
NodeStatusMaxImages: utilpointer.Int32(0),
NodeStatusMaxImages: ptr.To[int32](0),
MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(0),
KubeAPIQPS: ptr.To[int32](0),
KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(false),
SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: nil,
EvictionHard: map[string]string{},
EvictionSoft: map[string]string{},
EvictionSoftGracePeriod: map[string]string{},
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EvictionMinimumReclaim: map[string]string{},
EnableControllerAttachDetach: utilpointer.Bool(false),
MakeIPTablesUtilChains: utilpointer.Bool(false),
IPTablesMasqueradeBit: utilpointer.Int32(0),
IPTablesDropBit: utilpointer.Int32(0),
EnableControllerAttachDetach: ptr.To(false),
MakeIPTablesUtilChains: ptr.To(false),
IPTablesMasqueradeBit: ptr.To[int32](0),
IPTablesDropBit: ptr.To[int32](0),
FeatureGates: map[string]bool{},
FailSwapOn: utilpointer.Bool(false),
FailSwapOn: ptr.To(false),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: ""},
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(0),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](0),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
SystemReserved: map[string]string{},
@ -353,22 +353,22 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(false),
EnableSystemLogHandler: ptr.To(false),
ReservedMemory: []v1beta1.MemoryReservation{},
EnableProfilingHandler: utilpointer.Bool(false),
EnableDebugFlagsHandler: utilpointer.Bool(false),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(0),
RegisterNode: utilpointer.Bool(false),
LocalStorageCapacityIsolation: utilpointer.Bool(false),
EnableProfilingHandler: ptr.To(false),
EnableDebugFlagsHandler: ptr.To(false),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To[float64](0),
RegisterNode: ptr.To(false),
LocalStorageCapacityIsolation: ptr.To(false),
PodLogsDir: DefaultPodLogsDir,
},
},
{
"all positive",
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
StaticPodPath: "static/pod/path",
SyncFrequency: 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{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second},
},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(true)},
},
Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -399,15 +399,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32(1),
RegistryPullQPS: ptr.To[int32](1),
RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1),
EventRecordQPS: ptr.To[int32](1),
EventBurst: 1,
EnableDebuggingHandlers: utilpointer.Bool(true),
EnableDebuggingHandlers: ptr.To(true),
EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1),
HealthzPort: ptr.To[int32](1),
HealthzBindAddress: "127.0.0.2",
OOMScoreAdj: utilpointer.Int32(1),
OOMScoreAdj: ptr.To[int32](1),
ClusterDomain: "cluster-domain",
ClusterDNS: []string{"192.168.1.3"},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second},
@ -416,13 +416,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 1,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second},
ImageGCHighThresholdPercent: utilpointer.Int32(1),
ImageGCLowThresholdPercent: utilpointer.Int32(1),
ImageGCHighThresholdPercent: ptr.To[int32](1),
ImageGCLowThresholdPercent: ptr.To[int32](1),
VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second},
KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "systemd",
CPUManagerPolicy: "cpu-manager-policy",
CPUManagerPolicyOptions: map[string]string{"key": "value"},
@ -435,18 +435,18 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: v1beta1.HairpinVeth,
MaxPods: 1,
PodCIDR: "192.168.1.0/24",
PodPidsLimit: utilpointer.Int64(1),
ResolverConfig: utilpointer.String("resolver-config"),
PodPidsLimit: ptr.To[int64](1),
ResolverConfig: ptr.To("resolver-config"),
RunOnce: true,
CPUCFSQuota: utilpointer.Bool(true),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second},
NodeStatusMaxImages: utilpointer.Int32(1),
NodeStatusMaxImages: ptr.To[int32](1),
MaxOpenFiles: 1,
ContentType: "application/protobuf",
KubeAPIQPS: utilpointer.Int32(1),
KubeAPIQPS: ptr.To[int32](1),
KubeAPIBurst: 1,
SerializeImagePulls: utilpointer.Bool(true),
MaxParallelImagePulls: utilpointer.Int32(5),
SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: map[string]string{
"memory.available": "1Mi",
"nodefs.available": "1%",
@ -468,16 +468,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"imagefs.available": "1Gi",
},
PodsPerCore: 1,
EnableControllerAttachDetach: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
ProtectKernelDefaults: true,
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32(1),
IPTablesDropBit: utilpointer.Int32(1),
FailSwapOn: utilpointer.Bool(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](1),
IPTablesDropBit: ptr.To[int32](1),
FailSwapOn: ptr.To(true),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"},
ContainerLogMaxSize: "1Mi",
ContainerLogMaxFiles: utilpointer.Int32(1),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](1),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy,
SystemReserved: map[string]string{
@ -499,7 +499,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "json",
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},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second},
ReservedMemory: []v1beta1.MemoryReservation{
@ -508,17 +508,17 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")},
},
},
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(true),
FailCgroupV1: utilpointer.Bool(true),
MemoryThrottlingFactor: utilpointer.Float64(1),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(true),
FailCgroupV1: ptr.To(true),
MemoryThrottlingFactor: ptr.To[float64](1),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: "/custom/path",
},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
StaticPodPath: "static/pod/path",
SyncFrequency: 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{
X509: v1beta1.KubeletX509Authentication{ClientCAFile: "client-ca-file"},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second},
},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(true)},
},
Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -549,15 +549,15 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 60 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32(1),
RegistryPullQPS: ptr.To[int32](1),
RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1),
EventRecordQPS: ptr.To[int32](1),
EventBurst: 1,
EnableDebuggingHandlers: utilpointer.Bool(true),
EnableDebuggingHandlers: ptr.To(true),
EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1),
HealthzPort: ptr.To[int32](1),
HealthzBindAddress: "127.0.0.2",
OOMScoreAdj: utilpointer.Int32(1),
OOMScoreAdj: ptr.To[int32](1),
ClusterDomain: "cluster-domain",
ClusterDNS: []string{"192.168.1.3"},
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 60 * time.Second},
@ -566,13 +566,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeLeaseDurationSeconds: 1,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 60 * time.Second},
ImageGCHighThresholdPercent: utilpointer.Int32(1),
ImageGCLowThresholdPercent: utilpointer.Int32(1),
ImageGCHighThresholdPercent: ptr.To[int32](1),
ImageGCLowThresholdPercent: ptr.To[int32](1),
VolumeStatsAggPeriod: metav1.Duration{Duration: 60 * time.Second},
KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "systemd",
CPUManagerPolicy: "cpu-manager-policy",
CPUManagerPolicyOptions: map[string]string{"key": "value"},
@ -585,18 +585,18 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
HairpinMode: v1beta1.HairpinVeth,
MaxPods: 1,
PodCIDR: "192.168.1.0/24",
PodPidsLimit: utilpointer.Int64(1),
ResolverConfig: utilpointer.String("resolver-config"),
PodPidsLimit: ptr.To[int64](1),
ResolverConfig: ptr.To("resolver-config"),
RunOnce: true,
CPUCFSQuota: utilpointer.Bool(true),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 60 * time.Second},
NodeStatusMaxImages: utilpointer.Int32(1),
NodeStatusMaxImages: ptr.To[int32](1),
MaxOpenFiles: 1,
ContentType: "application/protobuf",
KubeAPIQPS: utilpointer.Int32(1),
KubeAPIQPS: ptr.To[int32](1),
KubeAPIBurst: 1,
SerializeImagePulls: utilpointer.Bool(true),
MaxParallelImagePulls: utilpointer.Int32Ptr(5),
SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: map[string]string{
"memory.available": "1Mi",
"nodefs.available": "1%",
@ -618,16 +618,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"imagefs.available": "1Gi",
},
PodsPerCore: 1,
EnableControllerAttachDetach: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
ProtectKernelDefaults: true,
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32(1),
IPTablesDropBit: utilpointer.Int32(1),
FailSwapOn: utilpointer.Bool(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](1),
IPTablesDropBit: ptr.To[int32](1),
FailSwapOn: ptr.To(true),
MemorySwap: v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"},
ContainerLogMaxSize: "1Mi",
ContainerLogMaxFiles: utilpointer.Int32(1),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](1),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.TTLCacheChangeDetectionStrategy,
SystemReserved: map[string]string{
@ -649,7 +649,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "json",
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},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 60 * time.Second},
ReservedMemory: []v1beta1.MemoryReservation{
@ -658,13 +658,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Limits: v1.ResourceList{v1.ResourceMemory: resource.MustParse("1Gi")},
},
},
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(true),
FailCgroupV1: utilpointer.Bool(true),
MemoryThrottlingFactor: utilpointer.Float64(1),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(true),
FailCgroupV1: ptr.To(true),
MemoryThrottlingFactor: ptr.To[float64](1),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: "/custom/path",
},
},
@ -674,16 +674,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute},
},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0",
Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
},
},
@ -694,24 +694,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32(5),
RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(50),
EventRecordQPS: ptr.To[int32](50),
EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32(10248),
EnableDebuggingHandlers: ptr.To(true),
HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(int32(qos.KubeletOOMScoreAdj)),
OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 1 * time.Minute},
NodeStatusReportFrequency: metav1.Duration{Duration: 1 * time.Minute},
NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32(85),
ImageGCLowThresholdPercent: utilpointer.Int32(80),
ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -721,27 +721,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true),
PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32(50),
NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32(50),
KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true),
SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: nil,
EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -750,33 +750,33 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir,
},
},
{
"SerializeImagePull defaults to false when MaxParallelImagePulls is larger than 1",
&v1beta1.KubeletConfiguration{
MaxParallelImagePulls: utilpointer.Int32(5),
MaxParallelImagePulls: ptr.To[int32](5),
},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0",
Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
},
},
@ -787,24 +787,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32Ptr(5),
RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(50),
EventRecordQPS: ptr.To[int32](50),
EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32Ptr(10248),
EnableDebuggingHandlers: ptr.To(true),
HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)),
OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32Ptr(85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80),
ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -814,27 +814,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true),
PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50),
NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(50),
KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(false),
MaxParallelImagePulls: utilpointer.Int32(5),
SerializeImagePulls: ptr.To(false),
MaxParallelImagePulls: ptr.To[int32](5),
EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -843,33 +843,33 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
PodLogsDir: DefaultPodLogsDir,
},
},
{
"SerializeImagePull defaults to true when MaxParallelImagePulls is set to 1",
&v1beta1.KubeletConfiguration{
MaxParallelImagePulls: utilpointer.Int32(1),
MaxParallelImagePulls: ptr.To[int32](1),
},
&v1beta1.KubeletConfiguration{
EnableServer: utilpointer.Bool(true),
EnableServer: ptr.To(true),
SyncFrequency: metav1.Duration{Duration: 1 * time.Minute},
FileCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
HTTPCheckFrequency: metav1.Duration{Duration: 20 * time.Second},
Address: "0.0.0.0",
Port: ports.KubeletPort,
Authentication: v1beta1.KubeletAuthentication{
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: ptr.To(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.Bool(true),
Enabled: ptr.To(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
},
},
@ -880,24 +880,24 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
CacheUnauthorizedTTL: metav1.Duration{Duration: 30 * time.Second},
},
},
RegistryPullQPS: utilpointer.Int32Ptr(5),
RegistryPullQPS: ptr.To[int32](5),
RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(50),
EventRecordQPS: ptr.To[int32](50),
EventBurst: 100,
EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32Ptr(10248),
EnableDebuggingHandlers: ptr.To(true),
HealthzPort: ptr.To[int32](10248),
HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)),
OOMScoreAdj: ptr.To(int32(qos.KubeletOOMScoreAdj)),
StreamingConnectionIdleTimeout: metav1.Duration{Duration: 4 * time.Hour},
NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Second},
NodeStatusReportFrequency: metav1.Duration{Duration: 5 * time.Minute},
NodeLeaseDurationSeconds: 40,
ContainerRuntimeEndpoint: "unix:///run/containerd/containerd.sock",
ImageMinimumGCAge: metav1.Duration{Duration: 2 * time.Minute},
ImageGCHighThresholdPercent: utilpointer.Int32Ptr(85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80),
ImageGCHighThresholdPercent: ptr.To[int32](85),
ImageGCLowThresholdPercent: ptr.To[int32](80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.Bool(true),
CgroupsPerQOS: ptr.To(true),
CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -907,27 +907,27 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RuntimeRequestTimeout: metav1.Duration{Duration: 2 * time.Minute},
HairpinMode: v1beta1.PromiscuousBridge,
MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.Bool(true),
PodPidsLimit: ptr.To[int64](-1),
ResolverConfig: ptr.To(kubetypes.ResolvConfDefault),
CPUCFSQuota: ptr.To(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50),
NodeStatusMaxImages: ptr.To[int32](50),
MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(50),
KubeAPIQPS: ptr.To[int32](50),
KubeAPIBurst: 100,
SerializeImagePulls: utilpointer.Bool(true),
MaxParallelImagePulls: utilpointer.Int32(1),
SerializeImagePulls: ptr.To(true),
MaxParallelImagePulls: ptr.To[int32](1),
EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.Bool(true),
EnableControllerAttachDetach: ptr.To(true),
MakeIPTablesUtilChains: ptr.To(true),
IPTablesMasqueradeBit: ptr.To[int32](DefaultIPTablesMasqueradeBit),
IPTablesDropBit: ptr.To[int32](DefaultIPTablesDropBit),
FailSwapOn: ptr.To(true),
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32(5),
ContainerLogMaxWorkers: utilpointer.Int32(1),
ContainerLogMaxFiles: ptr.To[int32](5),
ContainerLogMaxWorkers: ptr.To[int32](1),
ContainerLogMonitorInterval: &metav1.Duration{Duration: 10 * time.Second},
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
@ -936,14 +936,14 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text",
FlushFrequency: logsapi.TimeOrMetaDuration{Duration: metav1.Duration{Duration: 5 * time.Second}, SerializeAsString: true},
},
EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(false),
FailCgroupV1: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.Bool(true),
EnableSystemLogHandler: ptr.To(true),
EnableProfilingHandler: ptr.To(true),
EnableDebugFlagsHandler: ptr.To(true),
SeccompDefault: ptr.To(false),
FailCgroupV1: ptr.To(false),
MemoryThrottlingFactor: ptr.To(DefaultMemoryThrottlingFactor),
RegisterNode: ptr.To(true),
LocalStorageCapacityIsolation: ptr.To(true),
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"
"k8s.io/kubernetes/pkg/kubelet/apis/config/validation"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
utilpointer "k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
var (
@ -66,7 +66,7 @@ var (
TopologyManagerPolicy: kubeletconfig.SingleNumaNodeTopologyManagerPolicy,
ShutdownGracePeriod: metav1.Duration{Duration: 30 * time.Second},
ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 10 * time.Second},
MemoryThrottlingFactor: utilpointer.Float64(0.9),
MemoryThrottlingFactor: ptr.To(0.9),
FeatureGates: map[string]bool{
"CustomCPUCFSQuotaPeriod": true,
"GracefulNodeShutdown": true,
@ -278,14 +278,14 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, {
name: "invalid MaxParallelImagePulls",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(0)
conf.MaxParallelImagePulls = ptr.To[int32](0)
return conf
},
errMsg: "invalid configuration: maxParallelImagePulls 0 must be a positive number",
}, {
name: "invalid MaxParallelImagePulls and SerializeImagePulls combination",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(3)
conf.MaxParallelImagePulls = ptr.To[int32](3)
conf.SerializeImagePulls = true
return conf
},
@ -293,7 +293,7 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, {
name: "valid MaxParallelImagePulls and SerializeImagePulls combination",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MaxParallelImagePulls = utilpointer.Int32(1)
conf.MaxParallelImagePulls = ptr.To[int32](1)
conf.SerializeImagePulls = true
return conf
},
@ -454,7 +454,7 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, {
name: "invalid MemoryThrottlingFactor",
configure: func(conf *kubeletconfig.KubeletConfiguration) *kubeletconfig.KubeletConfiguration {
conf.MemoryThrottlingFactor = utilpointer.Float64(1.1)
conf.MemoryThrottlingFactor = ptr.To(1.1)
return conf
},
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/utils/sysfs"
"k8s.io/klog/v2"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
type cadvisorClient struct {
@ -98,7 +98,7 @@ func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, cgroupRoots [
duration := maxHousekeepingInterval
housekeepingConfig := manager.HousekeepingConfig{
Interval: &duration,
AllowDynamic: pointer.Bool(allowDynamicHousekeeping),
AllowDynamic: ptr.To(allowDynamicHousekeeping),
}
// 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/utils/clock"
testingclock "k8s.io/utils/clock/testing"
utilpointer "k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
func init() {
@ -3043,7 +3043,7 @@ func TestNewMainKubeletStandAlone(t *testing.T) {
ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy,
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: 5,
MemoryThrottlingFactor: utilpointer.Float64(0),
MemoryThrottlingFactor: ptr.To[float64](0),
}
var prober volume.DynamicPluginProber
tp := noopoteltrace.NewTracerProvider()
@ -3166,7 +3166,7 @@ func TestSyncPodSpans(t *testing.T) {
ConfigMapAndSecretChangeDetectionStrategy: kubeletconfiginternal.WatchChangeDetectionStrategy,
ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: 5,
MemoryThrottlingFactor: utilpointer.Float64(0),
MemoryThrottlingFactor: ptr.To[float64](0),
}
exp := tracetest.NewInMemoryExporter()
@ -3231,7 +3231,7 @@ func TestSyncPodSpans(t *testing.T) {
ImagePullPolicy: v1.PullAlways,
},
},
EnableServiceLinks: utilpointer.Bool(false),
EnableServiceLinks: ptr.To(false),
})
_, err = kubelet.SyncPod(context.Background(), kubetypes.SyncPodCreate, pod, nil, &kubecontainer.PodStatus{})

4
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/logs"
proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
utilpointer "k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
const (
@ -134,7 +134,7 @@ func newFakeKubeRuntimeManager(runtimeService internalapi.RuntimeService, imageS
kubeRuntimeManager,
flowcontrol.NewBackOff(time.Second, 300*time.Second),
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,
&fakePodPullingTimeRecorder{},

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

@ -34,7 +34,7 @@ import (
containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
const testPodLogsDirectory = "/var/log/pods"
@ -153,8 +153,8 @@ func TestCreatePodSandbox_RuntimeClass(t *testing.T) {
expectError bool
}{
"unspecified RuntimeClass": {rcn: nil, expectedHandler: ""},
"valid RuntimeClass": {rcn: pointer.String(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler},
"missing RuntimeClass": {rcn: pointer.String("phantom"), expectError: true},
"valid RuntimeClass": {rcn: ptr.To(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler},
"missing RuntimeClass": {rcn: ptr.To("phantom"), expectError: true},
}
for name, test := range tests {
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"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
func TestParsePodFullName(t *testing.T) {
@ -137,7 +137,7 @@ func TestCreateMirrorPod(t *testing.T) {
Kind: "Node",
Name: testNodeName,
UID: testNodeUID,
Controller: pointer.Bool(true),
Controller: ptr.To(true),
}
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"
statustest "k8s.io/kubernetes/pkg/kubelet/status/testing"
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,
@ -136,7 +136,7 @@ func TestTCPPortExhaustion(t *testing.T) {
StartedAt: metav1.Now(),
},
},
Started: utilpointer.Bool(true),
Started: ptr.To(true),
})
}
podManager.AddPod(&pod)

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

@ -24,7 +24,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
func TestLookupRuntimeHandler(t *testing.T) {
@ -33,10 +33,10 @@ func TestLookupRuntimeHandler(t *testing.T) {
expected string
expectError bool
}{
{rcn: pointer.String(""), expected: ""},
{rcn: pointer.String(rctest.EmptyRuntimeClass), expected: ""},
{rcn: pointer.String(rctest.SandboxRuntimeClass), expected: "kata-containers"},
{rcn: pointer.String("phantom"), expectError: true},
{rcn: ptr.To(""), expected: ""},
{rcn: ptr.To(rctest.EmptyRuntimeClass), expected: ""},
{rcn: ptr.To(rctest.SandboxRuntimeClass), expected: "kata-containers"},
{rcn: ptr.To("phantom"), expectError: true},
}
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"
statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
// Do some initialization to decode the query parameters correctly.
utilfeature "k8s.io/apiserver/pkg/util/feature"
@ -802,8 +802,8 @@ func TestContainerLogs(t *testing.T) {
podLogOption *v1.PodLogOptions
}{
"without tail": {"", &v1.PodLogOptions{}},
"with tail": {"?tailLines=5", &v1.PodLogOptions{TailLines: pointer.Int64(5)}},
"with legacy tail": {"?tail=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: ptr.To[int64](5)}},
"with tail all": {"?tail=all", &v1.PodLogOptions{}},
"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"
runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
"k8s.io/utils/pointer"
"k8s.io/utils/ptr"
)
var (
@ -648,13 +648,13 @@ func getNotReadyStatus(cName string) v1.ContainerStatus {
func getStartedStatus(cName string) v1.ContainerStatus {
return v1.ContainerStatus{
Name: cName,
Started: pointer.Bool(true),
Started: ptr.To(true),
}
}
func getNotStartedStatus(cName string) v1.ContainerStatus {
return v1.ContainerStatus{
Name: cName,
Started: pointer.Bool(false),
Started: ptr.To(false),
}
}