inject remoteRuntime to kubelet dependency

cmd/kubemark/BUILD

@@ -19,6 +19,7 @@ go_library(
         "//pkg/api/legacyscheme:go_default_library",
         "//pkg/kubelet/cadvisor/testing:go_default_library",
         "//pkg/kubelet/cm:go_default_library",
+        "//pkg/kubelet/remote/fake:go_default_library",
         "//pkg/kubemark:go_default_library",
         "//pkg/master/ports:go_default_library",
         "//pkg/util/iptables/testing:go_default_library",

cmd/kubemark/hollow-node.go

@@ -43,6 +43,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
+	fakeremote "k8s.io/kubernetes/pkg/kubelet/remote/fake"
 	"k8s.io/kubernetes/pkg/kubemark"
 	"k8s.io/kubernetes/pkg/master/ports"
 	fakeiptables "k8s.io/kubernetes/pkg/util/iptables/testing"
@@ -192,12 +193,14 @@ func run(config *hollowNodeConfig) {
 			NodeName: config.NodeName,
 		}
 		containerManager := cm.NewStubContainerManager()
+		fakeRemoteRuntime := fakeremote.NewFakeRemoteRuntime()
 
 		hollowKubelet := kubemark.NewHollowKubelet(
 			f, c,
 			client,
 			heartbeatClient,
 			cadvisorInterface,
+			fakeRemoteRuntime,
 			containerManager,
 		)
 		hollowKubelet.Run()

pkg/kubelet/BUILD

@@ -77,7 +77,6 @@ go_library(
         "//pkg/kubelet/prober:go_default_library",
         "//pkg/kubelet/prober/results:go_default_library",
         "//pkg/kubelet/remote:go_default_library",
-        "//pkg/kubelet/remote/fake:go_default_library",
         "//pkg/kubelet/runtimeclass:go_default_library",
         "//pkg/kubelet/secret:go_default_library",
         "//pkg/kubelet/server:go_default_library",

pkg/kubelet/dockershim/docker_service.go

@@ -179,8 +179,6 @@ func NewDockerClientFromConfig(config *ClientConfig) libdocker.Interface {
 			config.DockerEndpoint,
 			config.RuntimeRequestTimeout,
 			config.ImagePullProgressDeadline,
-			config.WithTraceDisabled,
-			config.EnableSleep,
 		)
 		return client
 	}

pkg/kubelet/dockershim/libdocker/client.go

@@ -84,19 +84,7 @@ func getDockerClient(dockerEndpoint string) (*dockerapi.Client, error) {
 // is the timeout for docker requests. If timeout is exceeded, the request
 // will be cancelled and throw out an error. If requestTimeout is 0, a default
 // value will be applied.
-func ConnectToDockerOrDie(dockerEndpoint string, requestTimeout, imagePullProgressDeadline time.Duration,
+func ConnectToDockerOrDie(dockerEndpoint string, requestTimeout, imagePullProgressDeadline time.Duration) Interface {
-	withTraceDisabled bool, enableSleep bool) Interface {
-	if dockerEndpoint == FakeDockerEndpoint {
-		fakeClient := NewFakeDockerClient()
-		if withTraceDisabled {
-			fakeClient = fakeClient.WithTraceDisabled()
-		}
-
-		if enableSleep {
-			fakeClient.EnableSleep = true
-		}
-		return fakeClient
-	}
 	client, err := getDockerClient(dockerEndpoint)
 	if err != nil {
 		klog.Fatalf("Couldn't connect to docker: %v", err)

pkg/kubelet/kubelet.go

@@ -93,7 +93,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/prober"
 	proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
 	"k8s.io/kubernetes/pkg/kubelet/remote"
-	fakeremote "k8s.io/kubernetes/pkg/kubelet/remote/fake"
 	"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
 	"k8s.io/kubernetes/pkg/kubelet/secret"
 	"k8s.io/kubernetes/pkg/kubelet/server"
@@ -265,6 +264,8 @@ type Dependencies struct {
 	DynamicPluginProber     volume.DynamicPluginProber
 	TLSOptions              *server.TLSOptions
 	KubeletConfigController *kubeletconfig.Controller
+	RemoteRuntimeService    internalapi.RuntimeService
+	RemoteImageService      internalapi.ImageManagerService
 }
 
 // makePodSourceConfig creates a config.PodConfig from the given
@@ -318,23 +319,6 @@ func makePodSourceConfig(kubeCfg *kubeletconfiginternal.KubeletConfiguration, ku
 	return cfg, nil
 }
 
-func getRuntimeAndImageServices(remoteRuntimeEndpoint string, remoteImageEndpoint string, runtimeRequestTimeout metav1.Duration) (internalapi.RuntimeService, internalapi.ImageManagerService, error) {
-	if remoteRuntimeEndpoint == fakeremote.FakeRemoteRuntimeEndpoint && remoteImageEndpoint == fakeremote.FakeRemoteImageEndpoint {
-		fakeRuntime := fakeremote.NewFakeRemoteRuntime()
-		return fakeRuntime.RuntimeService, fakeRuntime.ImageService, nil
-	}
-
-	rs, err := remote.NewRemoteRuntimeService(remoteRuntimeEndpoint, runtimeRequestTimeout.Duration)
-	if err != nil {
-		return nil, nil, err
-	}
-	is, err := remote.NewRemoteImageService(remoteImageEndpoint, runtimeRequestTimeout.Duration)
-	if err != nil {
-		return nil, nil, err
-	}
-	return rs, is, err
-}
-
 // NewMainKubelet instantiates a new Kubelet object along with all the required internal modules.
 // No initialization of Kubelet and its modules should happen here.
 func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
@@ -666,9 +650,19 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 	default:
 		return nil, fmt.Errorf("unsupported CRI runtime: %q", containerRuntime)
 	}
-	runtimeService, imageService, err := getRuntimeAndImageServices(remoteRuntimeEndpoint, remoteImageEndpoint, kubeCfg.RuntimeRequestTimeout)
+
-	if err != nil {
+	runtimeService, imageService := kubeDeps.RemoteRuntimeService, kubeDeps.RemoteImageService
-		return nil, err
+	if runtimeService == nil {
+		runtimeService, err = remote.NewRemoteRuntimeService(remoteRuntimeEndpoint, kubeCfg.RuntimeRequestTimeout.Duration)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if imageService == nil {
+		imageService, err = remote.NewRemoteImageService(remoteImageEndpoint, kubeCfg.RuntimeRequestTimeout.Duration)
+		if err != nil {
+			return nil, err
+		}
 	}
 	klet.runtimeService = runtimeService
 

pkg/kubelet/remote/fake/fake_runtime.go

@@ -28,14 +28,6 @@ import (
 	utilexec "k8s.io/utils/exec"
 )
 
-const (
-	// FakeRemoteRuntimeEndpoint used by kubemark hollow-node
-	FakeRemoteRuntimeEndpoint = "fake://runtime"
-
-	// FakeRemoteImageEndpoint used by kubemark hollow-node
-	FakeRemoteImageEndpoint = "fake://image"
-)
-
 // RemoteRuntime represents a fake remote container runtime.
 type RemoteRuntime struct {
 	server *grpc.Server

pkg/kubemark/hollow_kubelet.go

@@ -98,20 +98,23 @@ func NewHollowKubelet(
 	client *clientset.Clientset,
 	heartbeatClient *clientset.Clientset,
 	cadvisorInterface cadvisor.Interface,
+	remoteRuntime *fakeremote.RemoteRuntime,
 	containerManager cm.ContainerManager) *HollowKubelet {
 	d := &kubelet.Dependencies{
-		KubeClient:        client,
+		KubeClient:           client,
-		HeartbeatClient:   heartbeatClient,
+		HeartbeatClient:      heartbeatClient,
-		CAdvisorInterface: cadvisorInterface,
+		RemoteRuntimeService: remoteRuntime.RuntimeService,
-		Cloud:             nil,
+		RemoteImageService:   remoteRuntime.ImageService,
-		OSInterface:       &containertest.FakeOS{},
+		CAdvisorInterface:    cadvisorInterface,
-		ContainerManager:  containerManager,
+		Cloud:                nil,
-		VolumePlugins:     volumePlugins(),
+		OSInterface:          &containertest.FakeOS{},
-		TLSOptions:        nil,
+		ContainerManager:     containerManager,
-		OOMAdjuster:       oom.NewFakeOOMAdjuster(),
+		VolumePlugins:        volumePlugins(),
-		Mounter:           &mount.FakeMounter{},
+		TLSOptions:           nil,
-		Subpather:         &subpath.FakeSubpath{},
+		OOMAdjuster:          oom.NewFakeOOMAdjuster(),
-		HostUtil:          hostutil.NewFakeHostUtil(nil),
+		Mounter:              &mount.FakeMounter{},
+		Subpather:            &subpath.FakeSubpath{},
+		HostUtil:             hostutil.NewFakeHostUtil(nil),
 	}
 
 	return &HollowKubelet{
@@ -159,8 +162,6 @@ func GetHollowKubeletConfig(opt *HollowKubletOptions) (*options.KubeletFlags, *k
 	f.MaxPerPodContainerCount = 2
 	f.NodeLabels = opt.NodeLabels
 	f.ContainerRuntimeOptions.ContainerRuntime = kubetypes.RemoteContainerRuntime
-	f.RemoteRuntimeEndpoint = fakeremote.FakeRemoteRuntimeEndpoint
-	f.RemoteImageEndpoint = fakeremote.FakeRemoteImageEndpoint
 	f.RegisterNode = true
 	f.RegisterSchedulable = true
 	f.ProviderID = fmt.Sprintf("kubemark://%v", opt.NodeName)