k8s.io/kubernetes@v1.29.3/pkg/kubelet/kuberuntime/fake_kuberuntime_manager.go (about)

     1  /*
     2  Copyright 2016 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package kuberuntime
    18  
    19  import (
    20  	"context"
    21  	"net/http"
    22  	"time"
    23  
    24  	cadvisorapi "github.com/google/cadvisor/info/v1"
    25  	"go.opentelemetry.io/otel/trace"
    26  	v1 "k8s.io/api/core/v1"
    27  	"k8s.io/apimachinery/pkg/api/resource"
    28  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    29  	"k8s.io/apimachinery/pkg/types"
    30  	"k8s.io/client-go/tools/record"
    31  	"k8s.io/client-go/util/flowcontrol"
    32  	"k8s.io/component-base/logs/logreduction"
    33  	internalapi "k8s.io/cri-api/pkg/apis"
    34  	"k8s.io/kubernetes/pkg/credentialprovider"
    35  	"k8s.io/kubernetes/pkg/kubelet/cm"
    36  	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
    37  	"k8s.io/kubernetes/pkg/kubelet/images"
    38  	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
    39  	"k8s.io/kubernetes/pkg/kubelet/logs"
    40  	proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
    41  	utilpointer "k8s.io/utils/pointer"
    42  )
    43  
    44  const (
    45  	fakeSeccompProfileRoot = "/fakeSeccompProfileRoot"
    46  
    47  	fakeNodeAllocatableMemory = "32Gi"
    48  	fakeNodeAllocatableCPU    = "16"
    49  )
    50  
    51  type fakeHTTP struct {
    52  	req *http.Request
    53  	err error
    54  }
    55  
    56  func (f *fakeHTTP) Do(req *http.Request) (*http.Response, error) {
    57  	f.req = req
    58  	return nil, f.err
    59  }
    60  
    61  type fakePodStateProvider struct {
    62  	terminated map[types.UID]struct{}
    63  	removed    map[types.UID]struct{}
    64  }
    65  
    66  func newFakePodStateProvider() *fakePodStateProvider {
    67  	return &fakePodStateProvider{
    68  		terminated: make(map[types.UID]struct{}),
    69  		removed:    make(map[types.UID]struct{}),
    70  	}
    71  }
    72  
    73  func (f *fakePodStateProvider) IsPodTerminationRequested(uid types.UID) bool {
    74  	_, found := f.removed[uid]
    75  	return found
    76  }
    77  
    78  func (f *fakePodStateProvider) ShouldPodRuntimeBeRemoved(uid types.UID) bool {
    79  	_, found := f.terminated[uid]
    80  	return found
    81  }
    82  
    83  func (f *fakePodStateProvider) ShouldPodContentBeRemoved(uid types.UID) bool {
    84  	_, found := f.removed[uid]
    85  	return found
    86  }
    87  
    88  type fakePodPullingTimeRecorder struct{}
    89  
    90  func (f *fakePodPullingTimeRecorder) RecordImageStartedPulling(podUID types.UID) {}
    91  
    92  func (f *fakePodPullingTimeRecorder) RecordImageFinishedPulling(podUID types.UID) {}
    93  
    94  func newFakeKubeRuntimeManager(runtimeService internalapi.RuntimeService, imageService internalapi.ImageManagerService, machineInfo *cadvisorapi.MachineInfo, osInterface kubecontainer.OSInterface, runtimeHelper kubecontainer.RuntimeHelper, keyring credentialprovider.DockerKeyring, tracer trace.Tracer) (*kubeGenericRuntimeManager, error) {
    95  	ctx := context.Background()
    96  	recorder := &record.FakeRecorder{}
    97  	logManager, err := logs.NewContainerLogManager(runtimeService, osInterface, "1", 2)
    98  	if err != nil {
    99  		return nil, err
   100  	}
   101  	kubeRuntimeManager := &kubeGenericRuntimeManager{
   102  		recorder:               recorder,
   103  		cpuCFSQuota:            false,
   104  		cpuCFSQuotaPeriod:      metav1.Duration{Duration: time.Millisecond * 100},
   105  		livenessManager:        proberesults.NewManager(),
   106  		startupManager:         proberesults.NewManager(),
   107  		machineInfo:            machineInfo,
   108  		osInterface:            osInterface,
   109  		runtimeHelper:          runtimeHelper,
   110  		runtimeService:         runtimeService,
   111  		imageService:           imageService,
   112  		keyring:                keyring,
   113  		seccompProfileRoot:     fakeSeccompProfileRoot,
   114  		internalLifecycle:      cm.NewFakeInternalContainerLifecycle(),
   115  		logReduction:           logreduction.NewLogReduction(identicalErrorDelay),
   116  		logManager:             logManager,
   117  		memoryThrottlingFactor: 0.9,
   118  	}
   119  
   120  	typedVersion, err := runtimeService.Version(ctx, kubeRuntimeAPIVersion)
   121  	if err != nil {
   122  		return nil, err
   123  	}
   124  
   125  	podStateProvider := newFakePodStateProvider()
   126  	kubeRuntimeManager.containerGC = newContainerGC(runtimeService, podStateProvider, kubeRuntimeManager, tracer)
   127  	kubeRuntimeManager.podStateProvider = podStateProvider
   128  	kubeRuntimeManager.runtimeName = typedVersion.RuntimeName
   129  	kubeRuntimeManager.imagePuller = images.NewImageManager(
   130  		kubecontainer.FilterEventRecorder(recorder),
   131  		kubeRuntimeManager,
   132  		flowcontrol.NewBackOff(time.Second, 300*time.Second),
   133  		false,
   134  		utilpointer.Int32Ptr(0), // No limit on max parallel image pulls,
   135  		0,                       // Disable image pull throttling by setting QPS to 0,
   136  		0,
   137  		&fakePodPullingTimeRecorder{},
   138  	)
   139  	kubeRuntimeManager.runner = lifecycle.NewHandlerRunner(
   140  		&fakeHTTP{},
   141  		kubeRuntimeManager,
   142  		kubeRuntimeManager,
   143  		recorder)
   144  
   145  	kubeRuntimeManager.getNodeAllocatable = func() v1.ResourceList {
   146  		return v1.ResourceList{
   147  			v1.ResourceMemory: resource.MustParse(fakeNodeAllocatableMemory),
   148  			v1.ResourceCPU:    resource.MustParse(fakeNodeAllocatableCPU),
   149  		}
   150  	}
   151  
   152  	return kubeRuntimeManager, nil
   153  }