Remove RuntimeClass

pkg/api/pod/util.go

@@ -252,7 +252,7 @@ func DropDisabledAlphaFields(podSpec *api.PodSpec) {
 
 	DropDisabledRunAsGroupField(podSpec)
 
-	if !utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) && podSpec.RuntimeClassName != nil {
+	if podSpec.RuntimeClassName != nil {
 		podSpec.RuntimeClassName = nil
 	}
 

pkg/apis/core/validation/validation.go

@@ -3057,10 +3057,6 @@ func ValidatePodSpec(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
 		}
 	}
 
-	if spec.RuntimeClassName != nil && utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) {
-		allErrs = append(allErrs, ValidateRuntimeClassName(*spec.RuntimeClassName, fldPath.Child("runtimeClassName"))...)
-	}
-
 	return allErrs
 }
 

pkg/features/kube_features.go

@@ -251,12 +251,6 @@ const (
 	// Enable resource quota scope selectors
 	ResourceQuotaScopeSelectors utilfeature.Feature = "ResourceQuotaScopeSelectors"
 
-	// owner: @tallclair
-	// alpha: v1.12
-	//
-	// Enables RuntimeClass, for selecting between multiple runtimes to run a pod.
-	RuntimeClass utilfeature.Feature = "RuntimeClass"
-
 	// owner: @janosi
 	// alpha: v1.12
 	//
@@ -331,7 +325,6 @@ var defaultKubernetesFeatureGates = map[utilfeature.Feature]utilfeature.FeatureS
 	PodReadinessGates:                           {Default: true, PreRelease: utilfeature.Beta},
 	KubeletPluginsWatcher:                       {Default: true, PreRelease: utilfeature.GA},
 	ResourceQuotaScopeSelectors:                 {Default: true, PreRelease: utilfeature.Beta},
-	RuntimeClass:                                {Default: false, PreRelease: utilfeature.Alpha},
 	SCTPSupport:                                 {Default: false, PreRelease: utilfeature.Alpha},
 	VolumeSnapshotDataSource:                    {Default: false, PreRelease: utilfeature.Alpha},
 	ProcMountType:                               {Default: false, PreRelease: utilfeature.Alpha},

pkg/kubelet/kubelet.go

@@ -87,7 +87,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/prober"
 	proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
 	"k8s.io/kubernetes/pkg/kubelet/remote"
-	"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
 	"k8s.io/kubernetes/pkg/kubelet/secret"
 	"k8s.io/kubernetes/pkg/kubelet/server"
 	serverstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
@@ -659,10 +658,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 	}
 	klet.runtimeService = runtimeService
 
-	if utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) && kubeDeps.DynamicKubeClient != nil {
-		klet.runtimeClassManager = runtimeclass.NewManager(kubeDeps.DynamicKubeClient)
-	}
-
 	runtime, err := kuberuntime.NewKubeGenericRuntimeManager(
 		kubecontainer.FilterEventRecorder(kubeDeps.Recorder),
 		klet.livenessManager,
@@ -683,7 +678,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		imageService,
 		kubeDeps.ContainerManager.InternalContainerLifecycle(),
 		legacyLogProvider,
-		klet.runtimeClassManager,
 	)
 	if err != nil {
 		return nil, err
@@ -1207,9 +1201,6 @@ type Kubelet struct {
 
 	//  This flag indicates that kubelet should start plugin watcher utility server for discovering Kubelet plugins
 	enablePluginsWatcher bool
-
-	// Handles RuntimeClass objects for the Kubelet.
-	runtimeClassManager *runtimeclass.Manager
 }
 
 func allGlobalUnicastIPs() ([]net.IP, error) {
@@ -1436,11 +1427,6 @@ func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {
 	kl.statusManager.Start()
 	kl.probeManager.Start()
 
-	// Start syncing RuntimeClasses if enabled.
-	if kl.runtimeClassManager != nil {
-		go kl.runtimeClassManager.Run(wait.NeverStop)
-	}
-
 	// Start the pod lifecycle event generator.
 	kl.pleg.Start()
 	kl.syncLoop(updates, kl)

pkg/kubelet/kuberuntime/kuberuntime_manager.go

@@ -43,7 +43,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/images"
 	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
 	proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
-	"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
 	"k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/kubelet/util/cache"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
@@ -120,9 +119,6 @@ type kubeGenericRuntimeManager struct {
 
 	// A shim to legacy functions for backward compatibility.
 	legacyLogProvider LegacyLogProvider
-
-	// Manage RuntimeClass resources.
-	runtimeClassManager *runtimeclass.Manager
 }
 
 // KubeGenericRuntime is a interface contains interfaces for container runtime and command.
@@ -159,7 +155,6 @@ func NewKubeGenericRuntimeManager(
 	imageService internalapi.ImageManagerService,
 	internalLifecycle cm.InternalContainerLifecycle,
 	legacyLogProvider LegacyLogProvider,
-	runtimeClassManager *runtimeclass.Manager,
 ) (KubeGenericRuntime, error) {
 	kubeRuntimeManager := &kubeGenericRuntimeManager{
 		recorder:            recorder,
@@ -176,7 +171,6 @@ func NewKubeGenericRuntimeManager(
 		keyring:             credentialprovider.NewDockerKeyring(),
 		internalLifecycle:   internalLifecycle,
 		legacyLogProvider:   legacyLogProvider,
-		runtimeClassManager: runtimeClassManager,
 	}
 
 	typedVersion, err := kubeRuntimeManager.runtimeService.Version(kubeRuntimeAPIVersion)

pkg/kubelet/kuberuntime/kuberuntime_sandbox.go

@@ -51,16 +51,6 @@ func (m *kubeGenericRuntimeManager) createPodSandbox(pod *v1.Pod, attempt uint32
 	}
 
 	runtimeHandler := ""
-	if utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) && m.runtimeClassManager != nil {
-		runtimeHandler, err = m.runtimeClassManager.LookupRuntimeHandler(pod.Spec.RuntimeClassName)
-		if err != nil {
-			message := fmt.Sprintf("CreatePodSandbox for pod %q failed: %v", format.Pod(pod), err)
-			return "", message, err
-		}
-		if runtimeHandler != "" {
-			klog.V(2).Infof("Running pod %s with RuntimeHandler %q", format.Pod(pod), runtimeHandler)
-		}
-	}
 
 	podSandBoxID, err := m.runtimeService.RunPodSandbox(podSandboxConfig, runtimeHandler)
 	if err != nil {

pkg/kubelet/runtimeclass/BUILD

-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["runtimeclass_manager.go"],
-    importpath = "k8s.io/kubernetes/pkg/kubelet/runtimeclass",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
-        "//staging/src/k8s.io/client-go/dynamic:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [
-        ":package-srcs",
-        "//pkg/kubelet/runtimeclass/testing:all-srcs",
-    ],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["runtimeclass_manager_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//pkg/kubelet/runtimeclass/testing:go_default_library",
-        "//vendor/github.com/stretchr/testify/assert:go_default_library",
-        "//vendor/k8s.io/utils/pointer:go_default_library",
-    ],
-)

pkg/kubelet/runtimeclass/runtimeclass_manager.go

-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package runtimeclass
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/tools/cache"
-)
-
-var (
-	runtimeClassGVR = schema.GroupVersionResource{
-		Group:    "node.k8s.io",
-		Version:  "v1alpha1",
-		Resource: "runtimeclasses",
-	}
-)
-
-// Manager caches RuntimeClass API objects, and provides accessors to the Kubelet.
-type Manager struct {
-	informer cache.SharedInformer
-}
-
-// NewManager returns a new RuntimeClass Manager. Run must be called before the manager can be used.
-func NewManager(client dynamic.Interface) *Manager {
-	rc := client.Resource(runtimeClassGVR)
-	lw := &cache.ListWatch{
-		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-			return rc.List(options)
-		},
-		WatchFunc: rc.Watch,
-	}
-	informer := cache.NewSharedInformer(lw, &unstructured.Unstructured{}, 0)
-
-	return &Manager{
-		informer: informer,
-	}
-}
-
-// Run starts syncing the RuntimeClass cache with the apiserver.
-func (m *Manager) Run(stopCh <-chan struct{}) {
-	m.informer.Run(stopCh)
-}
-
-// LookupRuntimeHandler returns the RuntimeHandler string associated with the given RuntimeClass
-// name (or the default of "" for nil). If the RuntimeClass is not found, it returns an
-// apierrors.NotFound error.
-func (m *Manager) LookupRuntimeHandler(runtimeClassName *string) (string, error) {
-	if runtimeClassName == nil || *runtimeClassName == "" {
-		// The default RuntimeClass always resolves to the empty runtime handler.
-		return "", nil
-	}
-
-	name := *runtimeClassName
-	item, exists, err := m.informer.GetStore().GetByKey(name)
-	if err != nil {
-		return "", fmt.Errorf("Failed to lookup RuntimeClass %s: %v", name, err)
-	}
-	if !exists {
-		return "", errors.NewNotFound(schema.GroupResource{
-			Group:    runtimeClassGVR.Group,
-			Resource: runtimeClassGVR.Resource,
-		}, name)
-	}
-
-	rc, ok := item.(*unstructured.Unstructured)
-	if !ok {
-		return "", fmt.Errorf("unexpected RuntimeClass type %T", item)
-	}
-
-	handler, _, err := unstructured.NestedString(rc.Object, "spec", "runtimeHandler")
-	if err != nil {
-		return "", fmt.Errorf("Invalid RuntimeClass object: %v", err)
-	}
-
-	return handler, nil
-}

pkg/kubelet/runtimeclass/runtimeclass_manager_test.go

-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package runtimeclass_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
-	rctest "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing"
-	"k8s.io/utils/pointer"
-)
-
-func TestLookupRuntimeHandler(t *testing.T) {
-	tests := []struct {
-		rcn         *string
-		expected    string
-		expectError bool
-	}{
-		{rcn: nil, expected: ""},
-		{rcn: pointer.StringPtr(""), expected: ""},
-		{rcn: pointer.StringPtr(rctest.EmptyRuntimeClass), expected: ""},
-		{rcn: pointer.StringPtr(rctest.SandboxRuntimeClass), expected: "kata-containers"},
-		{rcn: pointer.StringPtr(rctest.InvalidRuntimeClass), expectError: true},
-		{rcn: pointer.StringPtr("phantom"), expectError: true},
-	}
-
-	manager := runtimeclass.NewManager(rctest.NewPopulatedDynamicClient())
-	defer rctest.StartManagerSync(t, manager)()
-
-	for _, test := range tests {
-		tname := "nil"
-		if test.rcn != nil {
-			tname = *test.rcn
-		}
-		t.Run(fmt.Sprintf("%q->%q(err:%v)", tname, test.expected, test.expectError), func(t *testing.T) {
-			handler, err := manager.LookupRuntimeHandler(test.rcn)
-			if test.expectError {
-				assert.Error(t, err, "handler=%q", handler)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, test.expected, handler)
-			}
-		})
-	}
-}

pkg/kubelet/runtimeclass/testing/BUILD

-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["fake_manager.go"],
-    importpath = "k8s.io/kubernetes/pkg/kubelet/runtimeclass/testing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//pkg/kubelet/runtimeclass:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//staging/src/k8s.io/client-go/dynamic:go_default_library",
-        "//staging/src/k8s.io/client-go/dynamic/fake:go_default_library",
-        "//vendor/github.com/stretchr/testify/require:go_default_library",
-        "//vendor/k8s.io/utils/pointer:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)

pkg/kubelet/runtimeclass/testing/fake_manager.go

-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package testing
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/dynamic"
-	fakedynamic "k8s.io/client-go/dynamic/fake"
-	"k8s.io/kubernetes/pkg/kubelet/runtimeclass"
-	"k8s.io/utils/pointer"
-)
-
-const (
-	// SandboxRuntimeClass is a valid RuntimeClass pre-populated in the populated dynamic client.
-	SandboxRuntimeClass = "sandbox"
-	// SandboxRuntimeHandler is the handler associated with the SandboxRuntimeClass.
-	SandboxRuntimeHandler = "kata-containers"
-
-	// EmptyRuntimeClass is a valid RuntimeClass without a handler pre-populated in the populated dynamic client.
-	EmptyRuntimeClass = "native"
-	// InvalidRuntimeClass is an invalid RuntimeClass pre-populated in the populated dynamic client.
-	InvalidRuntimeClass = "foo"
-)
-
-// NewPopulatedDynamicClient creates a dynamic client for use with the runtimeclass.Manager,
-// and populates it with a few test RuntimeClass objects.
-func NewPopulatedDynamicClient() dynamic.Interface {
-	invalidRC := NewUnstructuredRuntimeClass(InvalidRuntimeClass, "")
-	invalidRC.Object["spec"].(map[string]interface{})["runtimeHandler"] = true
-
-	client := fakedynamic.NewSimpleDynamicClient(runtime.NewScheme(),
-		NewUnstructuredRuntimeClass(EmptyRuntimeClass, ""),
-		NewUnstructuredRuntimeClass(SandboxRuntimeClass, SandboxRuntimeHandler),
-		invalidRC,
-	)
-	return client
-}
-
-// StartManagerSync runs the manager, and waits for startup by polling for the expected "native"
-// RuntimeClass to be populated. Returns a function to stop the manager, which should be called with
-// a defer:
-//     defer StartManagerSync(t, m)()
-// Any errors are considered fatal to the test.
-func StartManagerSync(t *testing.T, m *runtimeclass.Manager) func() {
-	stopCh := make(chan struct{})
-	go m.Run(stopCh)
-
-	// Wait for informer to populate.
-	err := wait.PollImmediate(100*time.Millisecond, wait.ForeverTestTimeout, func() (bool, error) {
-		_, err := m.LookupRuntimeHandler(pointer.StringPtr(EmptyRuntimeClass))
-		if err != nil {
-			if errors.IsNotFound(err) {
-				return false, nil
-			}
-			return false, err
-		}
-		return true, nil
-	})
-	require.NoError(t, err, "Failed to start manager")
-
-	return func() {
-		close(stopCh)
-	}
-}
-
-// NewUnstructuredRuntimeClass is a helper to generate an unstructured RuntimeClass resource with
-// the given name & handler.
-func NewUnstructuredRuntimeClass(name, handler string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": "node.k8s.io/v1alpha1",
-			"kind":       "RuntimeClass",
-			"metadata": map[string]interface{}{
-				"name": name,
-			},
-			"spec": map[string]interface{}{
-				"runtimeHandler": handler,
-			},
-		},
-	}
-}

plugin/pkg/auth/authorizer/rbac/bootstrappolicy/policy.go

@@ -161,10 +161,6 @@ func NodeRules() []rbacv1.PolicyRule {
 		nodePolicyRules = append(nodePolicyRules, volAttachRule)
 	}
 
-	// RuntimeClass
-	if utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) {
-		nodePolicyRules = append(nodePolicyRules, rbacv1helpers.NewRule("get", "list", "watch").Groups("node.k8s.io").Resources("runtimeclasses").RuleOrDie())
-	}
 	return nodePolicyRules
 }