github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 19:56:01 +00:00
Code Issues Projects Releases Wiki Activity

kubelet: Replace deprecated pointer function

Browse Source 
Signed-off-by: TommyStarK <thomasmilox@gmail.com>
This commit is contained in:
TommyStarK 2023-01-03 19:33:51 +01:00
parent 3aff1f97be
commit 1fcc8fbf59
11 changed files with 133 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -113,7 +113,7 @@ func Funcs(codecs runtimeserializer.CodecFactory) []interface{} {
obj.Logging.Format = "text" obj.Logging.Format = "text"
} }
obj.EnableSystemLogHandler = true obj.EnableSystemLogHandler = true
obj.MemoryThrottlingFactor = utilpointer.Float64Ptr(rand.Float64()) obj.MemoryThrottlingFactor = utilpointer.Float64(rand.Float64())
obj.LocalStorageCapacityIsolation = true obj.LocalStorageCapacityIsolation = true
}, },
} }

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

@ -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.BoolPtr(true) obj.EnableServer = utilpointer.Bool(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.BoolPtr(false) obj.Authentication.Anonymous.Enabled = utilpointer.Bool(false)
} }
if obj.Authentication.Webhook.Enabled == nil { if obj.Authentication.Webhook.Enabled == nil {
obj.Authentication.Webhook.Enabled = utilpointer.BoolPtr(true) obj.Authentication.Webhook.Enabled = utilpointer.Bool(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.Int32Ptr(5) obj.RegistryPullQPS = utilpointer.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.Int32Ptr(5) obj.EventRecordQPS = utilpointer.Int32(5)
} }
if obj.EventBurst == 0 { if obj.EventBurst == 0 {
obj.EventBurst = 10 obj.EventBurst = 10
} }
if obj.EnableDebuggingHandlers == nil { if obj.EnableDebuggingHandlers == nil {
obj.EnableDebuggingHandlers = utilpointer.BoolPtr(true) obj.EnableDebuggingHandlers = utilpointer.Bool(true)
} }
if obj.HealthzPort == nil { if obj.HealthzPort == nil {
obj.HealthzPort = utilpointer.Int32Ptr(10248) obj.HealthzPort = utilpointer.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.Int32Ptr(int32(qos.KubeletOOMScoreAdj)) obj.OOMScoreAdj = utilpointer.Int32(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.Int32Ptr(85) obj.ImageGCHighThresholdPercent = utilpointer.Int32(85)
} }
if obj.ImageGCLowThresholdPercent == nil { if obj.ImageGCLowThresholdPercent == nil {
obj.ImageGCLowThresholdPercent = utilpointer.Int32Ptr(80) obj.ImageGCLowThresholdPercent = utilpointer.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.BoolPtr(true) obj.CgroupsPerQOS = utilpointer.Bool(true)
} }
if obj.CgroupDriver == "" { if obj.CgroupDriver == "" {
obj.CgroupDriver = "cgroupfs" obj.CgroupDriver = "cgroupfs"
@ -185,13 +185,13 @@ func SetDefaults_KubeletConfiguration(obj *kubeletconfigv1beta1.KubeletConfigura
obj.ResolverConfig = utilpointer.String(kubetypes.ResolvConfDefault) obj.ResolverConfig = utilpointer.String(kubetypes.ResolvConfDefault)
} }
if obj.CPUCFSQuota == nil { if obj.CPUCFSQuota == nil {
obj.CPUCFSQuota = utilpointer.BoolPtr(true) obj.CPUCFSQuota = utilpointer.Bool(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.Int32Ptr(50) obj.NodeStatusMaxImages = utilpointer.Int32(50)
} }
if obj.MaxOpenFiles == 0 { if obj.MaxOpenFiles == 0 {
obj.MaxOpenFiles = 1000000 obj.MaxOpenFiles = 1000000
@ -200,37 +200,37 @@ 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.Int32Ptr(5) obj.KubeAPIQPS = utilpointer.Int32(5)
} }
if obj.KubeAPIBurst == 0 { if obj.KubeAPIBurst == 0 {
obj.KubeAPIBurst = 10 obj.KubeAPIBurst = 10
} }
if obj.SerializeImagePulls == nil { if obj.SerializeImagePulls == nil {
obj.SerializeImagePulls = utilpointer.BoolPtr(true) obj.SerializeImagePulls = utilpointer.Bool(true)
} }
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.BoolPtr(true) obj.EnableControllerAttachDetach = utilpointer.Bool(true)
} }
if obj.MakeIPTablesUtilChains == nil { if obj.MakeIPTablesUtilChains == nil {
obj.MakeIPTablesUtilChains = utilpointer.BoolPtr(true) obj.MakeIPTablesUtilChains = utilpointer.Bool(true)
} }
if obj.IPTablesMasqueradeBit == nil { if obj.IPTablesMasqueradeBit == nil {
obj.IPTablesMasqueradeBit = utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit) obj.IPTablesMasqueradeBit = utilpointer.Int32(DefaultIPTablesMasqueradeBit)
} }
if obj.IPTablesDropBit == nil { if obj.IPTablesDropBit == nil {
obj.IPTablesDropBit = utilpointer.Int32Ptr(DefaultIPTablesDropBit) obj.IPTablesDropBit = utilpointer.Int32(DefaultIPTablesDropBit)
} }
if obj.FailSwapOn == nil { if obj.FailSwapOn == nil {
obj.FailSwapOn = utilpointer.BoolPtr(true) obj.FailSwapOn = utilpointer.Bool(true)
} }
if obj.ContainerLogMaxSize == "" { if obj.ContainerLogMaxSize == "" {
obj.ContainerLogMaxSize = "10Mi" obj.ContainerLogMaxSize = "10Mi"
} }
if obj.ContainerLogMaxFiles == nil { if obj.ContainerLogMaxFiles == nil {
obj.ContainerLogMaxFiles = utilpointer.Int32Ptr(5) obj.ContainerLogMaxFiles = utilpointer.Int32(5)
} }
if obj.ConfigMapAndSecretChangeDetectionStrategy == "" { if obj.ConfigMapAndSecretChangeDetectionStrategy == "" {
obj.ConfigMapAndSecretChangeDetectionStrategy = kubeletconfigv1beta1.WatchChangeDetectionStrategy obj.ConfigMapAndSecretChangeDetectionStrategy = kubeletconfigv1beta1.WatchChangeDetectionStrategy
@ -244,25 +244,25 @@ 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.BoolPtr(true) obj.EnableSystemLogHandler = utilpointer.Bool(true)
} }
if obj.EnableProfilingHandler == nil { if obj.EnableProfilingHandler == nil {
obj.EnableProfilingHandler = utilpointer.BoolPtr(true) obj.EnableProfilingHandler = utilpointer.Bool(true)
} }
if obj.EnableDebugFlagsHandler == nil { if obj.EnableDebugFlagsHandler == nil {
obj.EnableDebugFlagsHandler = utilpointer.BoolPtr(true) obj.EnableDebugFlagsHandler = utilpointer.Bool(true)
} }
if obj.SeccompDefault == nil { if obj.SeccompDefault == nil {
obj.SeccompDefault = utilpointer.BoolPtr(false) obj.SeccompDefault = utilpointer.Bool(false)
} }
if obj.MemoryThrottlingFactor == nil { if obj.MemoryThrottlingFactor == nil {
obj.MemoryThrottlingFactor = utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor) obj.MemoryThrottlingFactor = utilpointer.Float64(DefaultMemoryThrottlingFactor)
} }
if obj.RegisterNode == nil { if obj.RegisterNode == nil {
obj.RegisterNode = utilpointer.BoolPtr(true) obj.RegisterNode = utilpointer.Bool(true)
} }
if obj.LocalStorageCapacityIsolation == nil { if obj.LocalStorageCapacityIsolation == nil {
obj.LocalStorageCapacityIsolation = utilpointer.BoolPtr(true) obj.LocalStorageCapacityIsolation = utilpointer.Bool(true)
} }
if obj.ContainerRuntimeEndpoint == "" { if obj.ContainerRuntimeEndpoint == "" {
obj.ContainerRuntimeEndpoint = "unix:///run/containerd/containerd.sock" obj.ContainerRuntimeEndpoint = "unix:///run/containerd/containerd.sock"

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

@ -43,16 +43,16 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
"empty config", "empty config",
&v1beta1.KubeletConfiguration{}, &v1beta1.KubeletConfiguration{},
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.BoolPtr(true), EnableServer: utilpointer.Bool(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.BoolPtr(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.BoolPtr(true), Enabled: utilpointer.Bool(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -63,24 +63,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: utilpointer.Int32(5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(5), EventRecordQPS: utilpointer.Int32(5),
EventBurst: 10, EventBurst: 10,
EnableDebuggingHandlers: utilpointer.BoolPtr(true), EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32Ptr(10248), HealthzPort: utilpointer.Int32(10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: utilpointer.Int32(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},
ImageGCHighThresholdPercent: utilpointer.Int32Ptr(85), ImageGCHighThresholdPercent: utilpointer.Int32(85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80), ImageGCLowThresholdPercent: utilpointer.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.BoolPtr(true), CgroupsPerQOS: utilpointer.Bool(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -92,23 +92,23 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.BoolPtr(true), CPUCFSQuota: utilpointer.Bool(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50), NodeStatusMaxImages: utilpointer.Int32(50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(5), KubeAPIQPS: utilpointer.Int32(5),
KubeAPIBurst: 10, KubeAPIBurst: 10,
SerializeImagePulls: utilpointer.BoolPtr(true), SerializeImagePulls: utilpointer.Bool(true),
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.BoolPtr(true), EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.BoolPtr(true), MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit), IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.BoolPtr(true), FailSwapOn: utilpointer.Bool(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32Ptr(5), ContainerLogMaxFiles: utilpointer.Int32(5),
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
VolumePluginDir: DefaultVolumePluginDir, VolumePluginDir: DefaultVolumePluginDir,
@ -116,19 +116,19 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: 5 * time.Second, FlushFrequency: 5 * time.Second,
}, },
EnableSystemLogHandler: utilpointer.BoolPtr(true), EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.BoolPtr(true), EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.BoolPtr(true), EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.BoolPtr(false), SeccompDefault: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.BoolPtr(true), RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(true), LocalStorageCapacityIsolation: utilpointer.Bool(true),
}, },
}, },
{ {
"all negative", "all negative",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.BoolPtr(false), EnableServer: utilpointer.Bool(false),
StaticPodPath: "", StaticPodPath: "",
SyncFrequency: zeroDuration, SyncFrequency: zeroDuration,
FileCheckFrequency: zeroDuration, FileCheckFrequency: zeroDuration,
@ -147,10 +147,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.BoolPtr(false), Enabled: utilpointer.Bool(false),
CacheTTL: zeroDuration, CacheTTL: zeroDuration,
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.BoolPtr(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook, Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -163,7 +163,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RegistryBurst: 0, RegistryBurst: 0,
EventRecordQPS: utilpointer.Int32(0), EventRecordQPS: utilpointer.Int32(0),
EventBurst: 0, EventBurst: 0,
EnableDebuggingHandlers: utilpointer.BoolPtr(false), EnableDebuggingHandlers: utilpointer.Bool(false),
EnableContentionProfiling: false, EnableContentionProfiling: false,
HealthzPort: utilpointer.Int32(0), HealthzPort: utilpointer.Int32(0),
HealthzBindAddress: "", HealthzBindAddress: "",
@ -182,7 +182,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
KubeletCgroups: "", KubeletCgroups: "",
SystemCgroups: "", SystemCgroups: "",
CgroupRoot: "", CgroupRoot: "",
CgroupsPerQOS: utilpointer.BoolPtr(false), CgroupsPerQOS: utilpointer.Bool(false),
CgroupDriver: "", CgroupDriver: "",
CPUManagerPolicy: "", CPUManagerPolicy: "",
CPUManagerPolicyOptions: map[string]string{}, CPUManagerPolicyOptions: map[string]string{},
@ -247,11 +247,11 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EnableDebugFlagsHandler: utilpointer.Bool(false), EnableDebugFlagsHandler: utilpointer.Bool(false),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: utilpointer.Float64(0),
RegisterNode: utilpointer.BoolPtr(false), RegisterNode: utilpointer.Bool(false),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(false), LocalStorageCapacityIsolation: utilpointer.Bool(false),
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.BoolPtr(false), EnableServer: utilpointer.Bool(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},
@ -262,10 +262,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.BoolPtr(false), Enabled: utilpointer.Bool(false),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.BoolPtr(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeWebhook, Mode: v1beta1.KubeletAuthorizationModeWebhook,
@ -278,7 +278,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32(0), EventRecordQPS: utilpointer.Int32(0),
EventBurst: 10, EventBurst: 10,
EnableDebuggingHandlers: utilpointer.BoolPtr(false), EnableDebuggingHandlers: utilpointer.Bool(false),
HealthzPort: utilpointer.Int32(0), HealthzPort: utilpointer.Int32(0),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32(0), OOMScoreAdj: utilpointer.Int32(0),
@ -292,7 +292,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
ImageGCHighThresholdPercent: utilpointer.Int32(0), ImageGCHighThresholdPercent: utilpointer.Int32(0),
ImageGCLowThresholdPercent: utilpointer.Int32(0), ImageGCLowThresholdPercent: utilpointer.Int32(0),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.BoolPtr(false), CgroupsPerQOS: utilpointer.Bool(false),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerPolicyOptions: map[string]string{}, CPUManagerPolicyOptions: map[string]string{},
@ -344,14 +344,14 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EnableDebugFlagsHandler: utilpointer.Bool(false), EnableDebugFlagsHandler: utilpointer.Bool(false),
SeccompDefault: utilpointer.Bool(false), SeccompDefault: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64(0), MemoryThrottlingFactor: utilpointer.Float64(0),
RegisterNode: utilpointer.BoolPtr(false), RegisterNode: utilpointer.Bool(false),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(false), LocalStorageCapacityIsolation: utilpointer.Bool(false),
}, },
}, },
{ {
"all positive", "all positive",
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.BoolPtr(true), EnableServer: utilpointer.Bool(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},
@ -370,10 +370,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.BoolPtr(true), Enabled: utilpointer.Bool(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second}, CacheTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.BoolPtr(true)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow, Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -386,7 +386,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RegistryBurst: 1, RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1), EventRecordQPS: utilpointer.Int32(1),
EventBurst: 1, EventBurst: 1,
EnableDebuggingHandlers: utilpointer.BoolPtr(true), EnableDebuggingHandlers: utilpointer.Bool(true),
EnableContentionProfiling: true, EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1), HealthzPort: utilpointer.Int32(1),
HealthzBindAddress: "127.0.0.2", HealthzBindAddress: "127.0.0.2",
@ -405,7 +405,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
KubeletCgroups: "kubelet-cgroup", KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup", SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup", CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.BoolPtr(true), CgroupsPerQOS: utilpointer.Bool(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"},
@ -492,11 +492,11 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(true), SeccompDefault: utilpointer.Bool(true),
MemoryThrottlingFactor: utilpointer.Float64(1), MemoryThrottlingFactor: utilpointer.Float64(1),
RegisterNode: utilpointer.BoolPtr(true), RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(true), LocalStorageCapacityIsolation: utilpointer.Bool(true),
}, },
&v1beta1.KubeletConfiguration{ &v1beta1.KubeletConfiguration{
EnableServer: utilpointer.BoolPtr(true), EnableServer: utilpointer.Bool(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},
@ -515,10 +515,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.BoolPtr(true), Enabled: utilpointer.Bool(true),
CacheTTL: metav1.Duration{Duration: 60 * time.Second}, CacheTTL: metav1.Duration{Duration: 60 * time.Second},
}, },
Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.BoolPtr(true)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(true)},
}, },
Authorization: v1beta1.KubeletAuthorization{ Authorization: v1beta1.KubeletAuthorization{
Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow, Mode: v1beta1.KubeletAuthorizationModeAlwaysAllow,
@ -531,7 +531,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
RegistryBurst: 1, RegistryBurst: 1,
EventRecordQPS: utilpointer.Int32(1), EventRecordQPS: utilpointer.Int32(1),
EventBurst: 1, EventBurst: 1,
EnableDebuggingHandlers: utilpointer.BoolPtr(true), EnableDebuggingHandlers: utilpointer.Bool(true),
EnableContentionProfiling: true, EnableContentionProfiling: true,
HealthzPort: utilpointer.Int32(1), HealthzPort: utilpointer.Int32(1),
HealthzBindAddress: "127.0.0.2", HealthzBindAddress: "127.0.0.2",
@ -550,7 +550,7 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
KubeletCgroups: "kubelet-cgroup", KubeletCgroups: "kubelet-cgroup",
SystemCgroups: "system-cgroup", SystemCgroups: "system-cgroup",
CgroupRoot: "root-cgroup", CgroupRoot: "root-cgroup",
CgroupsPerQOS: utilpointer.BoolPtr(true), CgroupsPerQOS: utilpointer.Bool(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"},
@ -637,8 +637,8 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
EnableDebugFlagsHandler: utilpointer.Bool(true), EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.Bool(true), SeccompDefault: utilpointer.Bool(true),
MemoryThrottlingFactor: utilpointer.Float64(1), MemoryThrottlingFactor: utilpointer.Float64(1),
RegisterNode: utilpointer.BoolPtr(true), RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(true), LocalStorageCapacityIsolation: utilpointer.Bool(true),
}, },
}, },
{ {
@ -647,16 +647,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.BoolPtr(true), EnableServer: utilpointer.Bool(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.BoolPtr(false)}, Anonymous: v1beta1.KubeletAnonymousAuthentication{Enabled: utilpointer.Bool(false)},
Webhook: v1beta1.KubeletWebhookAuthentication{ Webhook: v1beta1.KubeletWebhookAuthentication{
Enabled: utilpointer.BoolPtr(true), Enabled: utilpointer.Bool(true),
CacheTTL: metav1.Duration{Duration: 2 * time.Minute}, CacheTTL: metav1.Duration{Duration: 2 * time.Minute},
}, },
}, },
@ -667,24 +667,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: utilpointer.Int32(5),
RegistryBurst: 10, RegistryBurst: 10,
EventRecordQPS: utilpointer.Int32Ptr(5), EventRecordQPS: utilpointer.Int32(5),
EventBurst: 10, EventBurst: 10,
EnableDebuggingHandlers: utilpointer.BoolPtr(true), EnableDebuggingHandlers: utilpointer.Bool(true),
HealthzPort: utilpointer.Int32Ptr(10248), HealthzPort: utilpointer.Int32(10248),
HealthzBindAddress: "127.0.0.1", HealthzBindAddress: "127.0.0.1",
OOMScoreAdj: utilpointer.Int32Ptr(int32(qos.KubeletOOMScoreAdj)), OOMScoreAdj: utilpointer.Int32(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.Int32Ptr(85), ImageGCHighThresholdPercent: utilpointer.Int32(85),
ImageGCLowThresholdPercent: utilpointer.Int32Ptr(80), ImageGCLowThresholdPercent: utilpointer.Int32(80),
VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute}, VolumeStatsAggPeriod: metav1.Duration{Duration: time.Minute},
CgroupsPerQOS: utilpointer.BoolPtr(true), CgroupsPerQOS: utilpointer.Bool(true),
CgroupDriver: "cgroupfs", CgroupDriver: "cgroupfs",
CPUManagerPolicy: "none", CPUManagerPolicy: "none",
CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second}, CPUManagerReconcilePeriod: metav1.Duration{Duration: 10 * time.Second},
@ -696,23 +696,23 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
MaxPods: 110, MaxPods: 110,
PodPidsLimit: utilpointer.Int64(-1), PodPidsLimit: utilpointer.Int64(-1),
ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault), ResolverConfig: utilpointer.String(kubetypes.ResolvConfDefault),
CPUCFSQuota: utilpointer.BoolPtr(true), CPUCFSQuota: utilpointer.Bool(true),
CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond}, CPUCFSQuotaPeriod: &metav1.Duration{Duration: 100 * time.Millisecond},
NodeStatusMaxImages: utilpointer.Int32Ptr(50), NodeStatusMaxImages: utilpointer.Int32(50),
MaxOpenFiles: 1000000, MaxOpenFiles: 1000000,
ContentType: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf",
KubeAPIQPS: utilpointer.Int32Ptr(5), KubeAPIQPS: utilpointer.Int32(5),
KubeAPIBurst: 10, KubeAPIBurst: 10,
SerializeImagePulls: utilpointer.BoolPtr(true), SerializeImagePulls: utilpointer.Bool(true),
EvictionHard: nil, EvictionHard: nil,
EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute}, EvictionPressureTransitionPeriod: metav1.Duration{Duration: 5 * time.Minute},
EnableControllerAttachDetach: utilpointer.BoolPtr(true), EnableControllerAttachDetach: utilpointer.Bool(true),
MakeIPTablesUtilChains: utilpointer.BoolPtr(true), MakeIPTablesUtilChains: utilpointer.Bool(true),
IPTablesMasqueradeBit: utilpointer.Int32Ptr(DefaultIPTablesMasqueradeBit), IPTablesMasqueradeBit: utilpointer.Int32(DefaultIPTablesMasqueradeBit),
IPTablesDropBit: utilpointer.Int32Ptr(DefaultIPTablesDropBit), IPTablesDropBit: utilpointer.Int32(DefaultIPTablesDropBit),
FailSwapOn: utilpointer.BoolPtr(true), FailSwapOn: utilpointer.Bool(true),
ContainerLogMaxSize: "10Mi", ContainerLogMaxSize: "10Mi",
ContainerLogMaxFiles: utilpointer.Int32Ptr(5), ContainerLogMaxFiles: utilpointer.Int32(5),
ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy, ConfigMapAndSecretChangeDetectionStrategy: v1beta1.WatchChangeDetectionStrategy,
EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement, EnforceNodeAllocatable: DefaultNodeAllocatableEnforcement,
VolumePluginDir: DefaultVolumePluginDir, VolumePluginDir: DefaultVolumePluginDir,
@ -720,13 +720,13 @@ func TestSetDefaultsKubeletConfiguration(t *testing.T) {
Format: "text", Format: "text",
FlushFrequency: 5 * time.Second, FlushFrequency: 5 * time.Second,
}, },
EnableSystemLogHandler: utilpointer.BoolPtr(true), EnableSystemLogHandler: utilpointer.Bool(true),
EnableProfilingHandler: utilpointer.BoolPtr(true), EnableProfilingHandler: utilpointer.Bool(true),
EnableDebugFlagsHandler: utilpointer.BoolPtr(true), EnableDebugFlagsHandler: utilpointer.Bool(true),
SeccompDefault: utilpointer.BoolPtr(false), SeccompDefault: utilpointer.Bool(false),
MemoryThrottlingFactor: utilpointer.Float64Ptr(DefaultMemoryThrottlingFactor), MemoryThrottlingFactor: utilpointer.Float64(DefaultMemoryThrottlingFactor),
RegisterNode: utilpointer.BoolPtr(true), RegisterNode: utilpointer.Bool(true),
LocalStorageCapacityIsolation: utilpointer.BoolPtr(true), LocalStorageCapacityIsolation: utilpointer.Bool(true),
}, },
}, },
} }

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

@ -64,7 +64,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.Float64Ptr(0.8), MemoryThrottlingFactor: utilpointer.Float64(0.8),
FeatureGates: map[string]bool{ FeatureGates: map[string]bool{
"CustomCPUCFSQuotaPeriod": true, "CustomCPUCFSQuotaPeriod": true,
"GracefulNodeShutdown": true, "GracefulNodeShutdown": true,

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

@ -106,7 +106,7 @@ func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, cgroupRoots [
duration := maxHousekeepingInterval duration := maxHousekeepingInterval
housekeepingConfig := manager.HouskeepingConfig{ housekeepingConfig := manager.HouskeepingConfig{
Interval: &duration, Interval: &duration,
AllowDynamic: pointer.BoolPtr(allowDynamicHousekeeping), AllowDynamic: pointer.Bool(allowDynamicHousekeeping),
} }
// Create the cAdvisor container manager. // Create the cAdvisor container manager.

4
pkg/kubelet/kuberuntime/helpers_linux_test.go
View File

@ -260,7 +260,7 @@ func TestFieldProfile(t *testing.T) {
description: "SeccompProfileTypeLocalhost should return localhost", description: "SeccompProfileTypeLocalhost should return localhost",
scmpProfile: &v1.SeccompProfile{ scmpProfile: &v1.SeccompProfile{
Type: v1.SeccompProfileTypeLocalhost, Type: v1.SeccompProfileTypeLocalhost,
LocalhostProfile: utilpointer.StringPtr("profile.json"), LocalhostProfile: utilpointer.String("profile.json"),
}, },
rootPath: "/test/", rootPath: "/test/",
expectedProfile: "localhost//test/profile.json", expectedProfile: "localhost//test/profile.json",
@ -316,7 +316,7 @@ func TestFieldProfileDefaultSeccomp(t *testing.T) {
description: "SeccompProfileTypeLocalhost should return localhost", description: "SeccompProfileTypeLocalhost should return localhost",
scmpProfile: &v1.SeccompProfile{ scmpProfile: &v1.SeccompProfile{
Type: v1.SeccompProfileTypeLocalhost, Type: v1.SeccompProfileTypeLocalhost,
LocalhostProfile: utilpointer.StringPtr("profile.json"), LocalhostProfile: utilpointer.String("profile.json"),
}, },
rootPath: "/test/", rootPath: "/test/",
expectedProfile: "localhost//test/profile.json", expectedProfile: "localhost//test/profile.json",

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

@ -119,8 +119,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.StringPtr(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler}, "valid RuntimeClass": {rcn: pointer.String(rctest.SandboxRuntimeClass), expectedHandler: rctest.SandboxRuntimeHandler},
"missing RuntimeClass": {rcn: pointer.StringPtr("phantom"), expectError: true}, "missing RuntimeClass": {rcn: pointer.String("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) {

14
pkg/kubelet/kuberuntime/logs/logs_test.go
View File

@ -98,42 +98,42 @@ func TestReadLogs(t *testing.T) {
{ {
name: "using TailLines 2 should output last 2 lines", name: "using TailLines 2 should output last 2 lines",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
TailLines: pointer.Int64Ptr(2), TailLines: pointer.Int64(2),
}, },
expected: "line2\nline3\n", expected: "line2\nline3\n",
}, },
{ {
name: "using TailLines 4 should output all lines when the log has less than 4 lines", name: "using TailLines 4 should output all lines when the log has less than 4 lines",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
TailLines: pointer.Int64Ptr(4), TailLines: pointer.Int64(4),
}, },
expected: "line1\nline2\nline3\n", expected: "line1\nline2\nline3\n",
}, },
{ {
name: "using TailLines 0 should output nothing", name: "using TailLines 0 should output nothing",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
TailLines: pointer.Int64Ptr(0), TailLines: pointer.Int64(0),
}, },
expected: "", expected: "",
}, },
{ {
name: "using LimitBytes 9 should output first 9 bytes", name: "using LimitBytes 9 should output first 9 bytes",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
LimitBytes: pointer.Int64Ptr(9), LimitBytes: pointer.Int64(9),
}, },
expected: "line1\nlin", expected: "line1\nlin",
}, },
{ {
name: "using LimitBytes 100 should output all bytes when the log has less than 100 bytes", name: "using LimitBytes 100 should output all bytes when the log has less than 100 bytes",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
LimitBytes: pointer.Int64Ptr(100), LimitBytes: pointer.Int64(100),
}, },
expected: "line1\nline2\nline3\n", expected: "line1\nline2\nline3\n",
}, },
{ {
name: "using LimitBytes 0 should output nothing", name: "using LimitBytes 0 should output nothing",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
LimitBytes: pointer.Int64Ptr(0), LimitBytes: pointer.Int64(0),
}, },
expected: "", expected: "",
}, },
@ -162,7 +162,7 @@ func TestReadLogs(t *testing.T) {
name: "using follow combined with TailLines 2 should output the last 2 lines", name: "using follow combined with TailLines 2 should output the last 2 lines",
podLogOptions: v1.PodLogOptions{ podLogOptions: v1.PodLogOptions{
Follow: true, Follow: true,
TailLines: pointer.Int64Ptr(2), TailLines: pointer.Int64(2),
}, },
expected: "line2\nline3\n", expected: "line2\nline3\n",
}, },

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

@ -137,7 +137,7 @@ func TestCreateMirrorPod(t *testing.T) {
Kind: "Node", Kind: "Node",
Name: testNodeName, Name: testNodeName,
UID: testNodeUID, UID: testNodeUID,
Controller: pointer.BoolPtr(true), Controller: pointer.Bool(true),
} }
assert.Equal(t, expectedOwnerRef, createdPod.OwnerReferences[0]) assert.Equal(t, expectedOwnerRef, createdPod.OwnerReferences[0])
}) })

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

@ -33,10 +33,10 @@ func TestLookupRuntimeHandler(t *testing.T) {
expected string expected string
expectError bool expectError bool
}{ }{
{rcn: pointer.StringPtr(""), expected: ""}, {rcn: pointer.String(""), expected: ""},
{rcn: pointer.StringPtr(rctest.EmptyRuntimeClass), expected: ""}, {rcn: pointer.String(rctest.EmptyRuntimeClass), expected: ""},
{rcn: pointer.StringPtr(rctest.SandboxRuntimeClass), expected: "kata-containers"}, {rcn: pointer.String(rctest.SandboxRuntimeClass), expected: "kata-containers"},
{rcn: pointer.StringPtr("phantom"), expectError: true}, {rcn: pointer.String("phantom"), expectError: true},
} }
manager := runtimeclass.NewManager(rctest.NewPopulatedClient()) manager := runtimeclass.NewManager(rctest.NewPopulatedClient())

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

@ -811,8 +811,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.Int64Ptr(5)}}, "with tail": {"?tailLines=5", &v1.PodLogOptions{TailLines: pointer.Int64(5)}},
"with legacy tail": {"?tail=5", &v1.PodLogOptions{TailLines: pointer.Int64Ptr(5)}}, "with legacy tail": {"?tail=5", &v1.PodLogOptions{TailLines: pointer.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}},
} }