runonce_test.go

Documentation: k8s.io/kubernetes/pkg/kubelet

     1  /*
     2  Copyright 2014 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 kubelet
    18  
    19  import (
    20  	"context"
    21  	"os"
    22  	"path/filepath"
    23  	"testing"
    24  	"time"
    25  
    26  	"github.com/golang/mock/gomock"
    27  	cadvisorapi "github.com/google/cadvisor/info/v1"
    28  	cadvisorapiv2 "github.com/google/cadvisor/info/v2"
    29  	"k8s.io/mount-utils"
    30  
    31  	v1 "k8s.io/api/core/v1"
    32  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    33  	"k8s.io/apimachinery/pkg/types"
    34  	"k8s.io/client-go/kubernetes/fake"
    35  	"k8s.io/client-go/tools/record"
    36  	utiltesting "k8s.io/client-go/util/testing"
    37  	cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing"
    38  	"k8s.io/kubernetes/pkg/kubelet/clustertrustbundle"
    39  	"k8s.io/kubernetes/pkg/kubelet/cm"
    40  	"k8s.io/kubernetes/pkg/kubelet/configmap"
    41  	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
    42  	containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
    43  	"k8s.io/kubernetes/pkg/kubelet/eviction"
    44  	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
    45  	podtest "k8s.io/kubernetes/pkg/kubelet/pod/testing"
    46  	"k8s.io/kubernetes/pkg/kubelet/secret"
    47  	"k8s.io/kubernetes/pkg/kubelet/server/stats"
    48  	"k8s.io/kubernetes/pkg/kubelet/status"
    49  	statustest "k8s.io/kubernetes/pkg/kubelet/status/testing"
    50  	kubeletutil "k8s.io/kubernetes/pkg/kubelet/util"
    51  	"k8s.io/kubernetes/pkg/kubelet/volumemanager"
    52  	"k8s.io/kubernetes/pkg/volume"
    53  	volumetest "k8s.io/kubernetes/pkg/volume/testing"
    54  	"k8s.io/kubernetes/pkg/volume/util/hostutil"
    55  	"k8s.io/utils/clock"
    56  )
    57  
    58  func TestRunOnce(t *testing.T) {
    59  	ctx := context.Background()
    60  	mockCtrl := gomock.NewController(t)
    61  	defer mockCtrl.Finish()
    62  
    63  	cadvisor := cadvisortest.NewMockInterface(mockCtrl)
    64  	cadvisor.EXPECT().MachineInfo().Return(&cadvisorapi.MachineInfo{}, nil).AnyTimes()
    65  	cadvisor.EXPECT().ImagesFsInfo().Return(cadvisorapiv2.FsInfo{
    66  		Usage:     400,
    67  		Capacity:  1000,
    68  		Available: 600,
    69  	}, nil).AnyTimes()
    70  	cadvisor.EXPECT().RootFsInfo().Return(cadvisorapiv2.FsInfo{
    71  		Usage:    9,
    72  		Capacity: 10,
    73  	}, nil).AnyTimes()
    74  	fakeSecretManager := secret.NewFakeManager()
    75  	fakeConfigMapManager := configmap.NewFakeManager()
    76  	clusterTrustBundleManager := &clustertrustbundle.NoopManager{}
    77  	podManager := kubepod.NewBasicPodManager()
    78  	fakeRuntime := &containertest.FakeRuntime{}
    79  	podStartupLatencyTracker := kubeletutil.NewPodStartupLatencyTracker()
    80  	basePath, err := utiltesting.MkTmpdir("kubelet")
    81  	if err != nil {
    82  		t.Fatalf("can't make a temp rootdir %v", err)
    83  	}
    84  	defer os.RemoveAll(basePath)
    85  	kb := &Kubelet{
    86  		rootDirectory:    filepath.Clean(basePath),
    87  		podLogsDirectory: filepath.Join(basePath, "pod-logs"),
    88  		recorder:         &record.FakeRecorder{},
    89  		cadvisor:         cadvisor,
    90  		nodeLister:       testNodeLister{},
    91  		statusManager:    status.NewManager(nil, podManager, &statustest.FakePodDeletionSafetyProvider{}, podStartupLatencyTracker, basePath),
    92  		mirrorPodClient:  podtest.NewFakeMirrorClient(),
    93  		podManager:       podManager,
    94  		podWorkers:       &fakePodWorkers{},
    95  		os:               &containertest.FakeOS{},
    96  		containerRuntime: fakeRuntime,
    97  		reasonCache:      NewReasonCache(),
    98  		clock:            clock.RealClock{},
    99  		kubeClient:       &fake.Clientset{},
   100  		hostname:         testKubeletHostname,
   101  		nodeName:         testKubeletHostname,
   102  		runtimeState:     newRuntimeState(time.Second),
   103  		hostutil:         hostutil.NewFakeHostUtil(nil),
   104  	}
   105  	kb.containerManager = cm.NewStubContainerManager()
   106  
   107  	plug := &volumetest.FakeVolumePlugin{PluginName: "fake", Host: nil}
   108  	kb.volumePluginMgr, err =
   109  		NewInitializedVolumePluginMgr(kb, fakeSecretManager, fakeConfigMapManager, nil, clusterTrustBundleManager, []volume.VolumePlugin{plug}, nil /* prober */)
   110  	if err != nil {
   111  		t.Fatalf("failed to initialize VolumePluginMgr: %v", err)
   112  	}
   113  	kb.volumeManager = volumemanager.NewVolumeManager(
   114  		true,
   115  		kb.nodeName,
   116  		kb.podManager,
   117  		kb.podWorkers,
   118  		kb.kubeClient,
   119  		kb.volumePluginMgr,
   120  		fakeRuntime,
   121  		kb.mounter,
   122  		kb.hostutil,
   123  		kb.getPodsDir(),
   124  		kb.recorder,
   125  		false, /* keepTerminatedPodVolumes */
   126  		volumetest.NewBlockVolumePathHandler())
   127  
   128  	// TODO: Factor out "stats.Provider" from Kubelet so we don't have a cyclic dependency
   129  	volumeStatsAggPeriod := time.Second * 10
   130  	kb.resourceAnalyzer = stats.NewResourceAnalyzer(kb, volumeStatsAggPeriod, kb.recorder)
   131  	nodeRef := &v1.ObjectReference{
   132  		Kind:      "Node",
   133  		Name:      string(kb.nodeName),
   134  		UID:       types.UID(kb.nodeName),
   135  		Namespace: "",
   136  	}
   137  	fakeKillPodFunc := func(pod *v1.Pod, evict bool, gracePeriodOverride *int64, fn func(*v1.PodStatus)) error {
   138  		return nil
   139  	}
   140  	evictionManager, evictionAdmitHandler := eviction.NewManager(kb.resourceAnalyzer, eviction.Config{}, fakeKillPodFunc, nil, nil, kb.recorder, nodeRef, kb.clock, kb.supportLocalStorageCapacityIsolation())
   141  
   142  	kb.evictionManager = evictionManager
   143  	kb.admitHandlers.AddPodAdmitHandler(evictionAdmitHandler)
   144  	kb.mounter = mount.NewFakeMounter(nil)
   145  	if err := kb.setupDataDirs(); err != nil {
   146  		t.Errorf("Failed to init data dirs: %v", err)
   147  	}
   148  
   149  	pods := []*v1.Pod{
   150  		{
   151  			ObjectMeta: metav1.ObjectMeta{
   152  				UID:       "12345678",
   153  				Name:      "foo",
   154  				Namespace: "new",
   155  			},
   156  			Spec: v1.PodSpec{
   157  				Containers: []v1.Container{
   158  					{Name: "bar"},
   159  				},
   160  			},
   161  		},
   162  	}
   163  	podManager.SetPods(pods)
   164  	// The original test here is totally meaningless, because fakeruntime will always return an empty podStatus. While
   165  	// the original logic of isPodRunning happens to return true when podstatus is empty, so the test can always pass.
   166  	// Now the logic in isPodRunning is changed, to let the test pass, we set the podstatus directly in fake runtime.
   167  	// This is also a meaningless test, because the isPodRunning will also always return true after setting this. However,
   168  	// because runonce is never used in kubernetes now, we should deprioritize the cleanup work.
   169  	// TODO(random-liu) Fix the test, make it meaningful.
   170  	fakeRuntime.PodStatus = kubecontainer.PodStatus{
   171  		ContainerStatuses: []*kubecontainer.Status{
   172  			{
   173  				Name:  "bar",
   174  				State: kubecontainer.ContainerStateRunning,
   175  			},
   176  		},
   177  	}
   178  	results, err := kb.runOnce(ctx, pods, time.Millisecond)
   179  	if err != nil {
   180  		t.Errorf("unexpected error: %v", err)
   181  	}
   182  	if results[0].Err != nil {
   183  		t.Errorf("unexpected run pod error: %v", results[0].Err)
   184  	}
   185  	if results[0].Pod.Name != "foo" {
   186  		t.Errorf("unexpected pod: %q", results[0].Pod.Name)
   187  	}
   188  }
   189
View as plain text