cdi: example driver

The logic of the driver is very simple (no real allocation, just set some env variables). The main purpose is to develop and test the code that integrates with Kubernetes.
pohly · pohly · Jun 1, 2022 · Jun 21, 2022 · Jun 24, 2022 · Jun 27, 2022
commit a331efcd0cd42ad168e58e24621dc66739a4dcf3
diff --git a/test/integration/cdi/example-driver/OWNERS b/test/integration/cdi/example-driver/OWNERS
@@ -0,0 +1,11 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+  - klueska
+  - pohly
+reviewers:
+  - klueska
+  - pohly
+  - bart0sh
+labels:
+  - sig/node
diff --git a/test/integration/cdi/example-driver/README.md b/test/integration/cdi/example-driver/README.md
@@ -0,0 +1,68 @@
+# cdi-example-driver
+
+The cdi-example-driver implements a resource driver controller and a resource
+kubelet plugin in a single binary. This is done in a single binary to minimize
+the amount of boilerplate code. "Real" drivers could also implement both in
+different binaries.
+
+## Usage
+
+The cdi-example-driver can get deployed as a Deployment for the controller,
+with leader election. A DaemonSet is used for the kubelet plugin. It can also
+run as a Kubernetes client outside of a cluster.
+
+The actual functionality is initially very limited. Resources are unlimited, so
+all ResourceClaims can be allocated. Valid ResourceClaims parameters are
+key/value string pairs:
+
+```yaml
+kind: ResourceClaim
+spec:
+  parameters:
+    some: example
+    another: example2
+```
+
+Those get copied into the ResourceClaimStatus with "user_" and "admin_" as
+prefix, depending on whether they came from the ResourceClaim or ResourceClass:
+
+```yaml
+kind: ResourceClaim
+status:
+  phase: Allocated
+  allocation:
+    userLimit: -1
+    attributes:
+      user_some: example
+      user_another: example
+```
+
+The kubelet plugin then sets these attributes as environment variables in each
+container that uses the resource.
+
+While the functionality itself is very limited, the code strives to showcase
+best practices and supports metrics, leader election, and the same logging
+options as Kubernetes.
+
+## Design
+
+The binary itself is a Cobra command with two operations, `controller` and
+`kubelet-plugin`. Logging is done with [contextual
+logging](https://github.com/kubernetes/enhancements/tree/master/keps/sig-instrumentation/3077-contextual-logging).
+
+The `controller` package implements the interaction with
+ResourceClaims. It is generic and relies on an interface to implement the
+actual driver logic. Long-term that part could be split out into a reusable
+utility package.
+
+`app` is the driver itself with a very simple implementation of the interface
+expected by `controller`.
+
+## Prior art
+
+Some of this code was derived from the
+[external-resizer](https://github.com/kubernetes-csi/external-resizer/). `controller`
+corresponds to the [controller
+logic](https://github.com/kubernetes-csi/external-resizer/blob/master/pkg/controller/controller.go),
+which in turn is similar to the
+[sig-storage-lib-external-provisioner](https://github.com/kubernetes-sigs/sig-storage-lib-external-provisioner).
diff --git a/test/integration/cdi/example-driver/app/controller.go b/test/integration/cdi/example-driver/app/controller.go
@@ -0,0 +1,111 @@
+/*
+Copyright 2022 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 app does all of the work necessary to configure and run a
+// Kubernetes app process.
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes"
+
+	"k8s.io/kubernetes/test/integration/cdi/example-driver/controller"
+)
+
+func runController(ctx context.Context, clientset kubernetes.Interface, driverName string, workers int) {
+	driver := &exampleDriver{
+		clientset: clientset,
+	}
+	informerFactory := informers.NewSharedInformerFactory(clientset, 0 /* resync period */)
+	ctrl := controller.New(ctx, driverName, driver, clientset, informerFactory)
+	informerFactory.Start(ctx.Done())
+	ctrl.Run(workers)
+}
+
+type exampleDriver struct {
+	clientset kubernetes.Interface
+}
+type parameters map[string]string
+
+var _ controller.Driver = exampleDriver{}
+
+func (d exampleDriver) GetClassParameters(ctx context.Context, class *corev1.ResourceClass) (interface{}, error) {
+	// TODO: read config map, but from what namespace?!
+	var p parameters
+	return p, nil
+}
+
+func (d exampleDriver) GetClaimParameters(ctx context.Context, claim *corev1.ResourceClaim, class *corev1.ResourceClass, classParameters interface{}) (interface{}, error) {
+	if claim.Spec.Parameters != nil {
+		if claim.Spec.Parameters.APIVersion != "v1" ||
+			claim.Spec.Parameters.Kind != "ConfigMap" {
+			return nil, fmt.Errorf("claim parameters are only supported in APIVersion v1, Kind ConfigMap, got: %v", claim.Spec.Parameters)
+		}
+		return d.readParametersFromConfigMap(ctx, claim.Namespace, claim.Spec.Parameters.Name)
+	}
+	return nil, nil
+}
+
+func (d exampleDriver) readParametersFromConfigMap(ctx context.Context, namespace, name string) (parameters, error) {
+	configMap, err := d.clientset.CoreV1().ConfigMaps(namespace).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("get config map: %v", err)
+	}
+	return parameters(configMap.Data), nil
+}
+
+// Allocate simply copies parameters as JSON map into ResourceHandle.
+func (d exampleDriver) Allocate(ctx context.Context, claim *corev1.ResourceClaim, claimParameters interface{}, class *corev1.ResourceClass, classParameters interface{}, selectedNode string) (*corev1.AllocationResult, error) {
+	allocation := &corev1.AllocationResult{
+		SharedResource: true,
+	}
+	p := parameters{}
+	toEnvVars("user", claimParameters.(parameters), p)
+	toEnvVars("admin", classParameters.(parameters), p)
+	data, err := json.Marshal(p)
+	if err != nil {
+		return nil, fmt.Errorf("encode env variables: %v", err)
+	}
+	allocation.ResourceHandle = string(data)
+	return allocation, nil
+}
+
+func (d exampleDriver) StopAllocation(ctx context.Context, claim *corev1.ResourceClaim) error {
+	return nil
+}
+
+func (d exampleDriver) Deallocate(ctx context.Context, claim *corev1.ResourceClaim) error {
+	return nil
+}
+
+func (d exampleDriver) UnsuitableNodes(ctx context.Context, pod *v1.Pod, claims []*controller.ClaimAllocation, potentialNodes []string) error {
+	// All nodes are suitable.
+	return nil
+}
+
+func toEnvVars(what string, from, to parameters) {
+	for key, value := range from {
+		to[what+"_"+strings.ToLower(key)] = value
+	}
+}