Add feature gates support for Kubeadm

pkg/minikube/bootstrapper/kubeadm/kubeadm.go

@@ -243,14 +243,21 @@ func NewKubeletConfig(k8s config.KubernetesConfig) (string, error) {
 
 	extraOpts = SetContainerRuntime(extraOpts, k8s.ContainerRuntime)
 	extraFlags := convertToFlags(extraOpts)
+
+	// parses a map of the feature gates for kubelet
+	_, kubeletFeatureArgs, err := ParseFeatureArgs(k8s.FeatureGates)
+	if err != nil {
+		return "", errors.Wrap(err, "parses feature gate config for kubelet")
+	}
+
 	b := bytes.Buffer{}
 	opts := struct {
 		ExtraOptions     string
 		FeatureGates     string
 		ContainerRuntime string
 	}{
 		ExtraOptions:     extraFlags,
-		FeatureGates:     k8s.FeatureGates,
+		FeatureGates:     kubeletFeatureArgs,
 		ContainerRuntime: k8s.ContainerRuntime,
 	}
 	if err := kubeletSystemdTemplate.Execute(&b, opts); err != nil {
@@ -334,8 +341,14 @@ func generateConfig(k8s config.KubernetesConfig) (string, error) {
 		return "", errors.Wrap(err, "parsing kubernetes version")
 	}
 
+	// parses a map of the feature gates for kubeadm and component
+	kubeadmFeatureArgs, componentFeatureArgs, err := ParseFeatureArgs(k8s.FeatureGates)
+	if err != nil {
+		return "", errors.Wrap(err, "parses feature gate config for kubeadm and component")
+	}
+
 	// generates a map of component to extra args for apiserver, controller-manager, and scheduler
-	extraComponentConfig, err := NewComponentExtraArgs(k8s.ExtraOptions, version, k8s.FeatureGates)
+	extraComponentConfig, err := NewComponentExtraArgs(k8s.ExtraOptions, version, componentFeatureArgs)
 	if err != nil {
 		return "", errors.Wrap(err, "generating extra component config for kubeadm")
 	}
@@ -349,6 +362,7 @@ func generateConfig(k8s config.KubernetesConfig) (string, error) {
 		EtcdDataDir       string
 		NodeName          string
 		ExtraArgs         []ComponentExtraArgs
+		FeatureArgs       map[string]bool
 	}{
 		CertDir:           util.DefaultCertPath,
 		ServiceCIDR:       util.DefaultServiceCIDR,
@@ -358,6 +372,7 @@ func generateConfig(k8s config.KubernetesConfig) (string, error) {
 		EtcdDataDir:       "/data/minikube", //TODO(r2d4): change to something else persisted
 		NodeName:          k8s.NodeName,
 		ExtraArgs:         extraComponentConfig,
+		FeatureArgs:       kubeadmFeatureArgs,
 	}
 
 	b := bytes.Buffer{}

pkg/minikube/bootstrapper/kubeadm/templates.go

@@ -38,6 +38,8 @@ etcd:
 nodeName: {{.NodeName}}
 {{range .ExtraArgs}}{{.Component}}:{{range $i, $val := printMapInOrder .Options ": " }}
   {{$val}}{{end}}
+{{end}}{{if .FeatureArgs}}featureGates: {{range $i, $val := .FeatureArgs}}
+  {{$i}}: {{$val}}{{end}}
 {{end}}`))
 
 var kubeletSystemdTemplate = template.Must(template.New("kubeletSystemdTemplate").Parse(`

pkg/minikube/bootstrapper/kubeadm/versions.go

@@ -20,11 +20,13 @@ import (
 	"fmt"
 	"path"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/blang/semver"
 	"github.com/golang/glog"
 	"github.com/pkg/errors"
+	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 	"k8s.io/minikube/pkg/minikube/constants"
 	"k8s.io/minikube/pkg/util"
 )
@@ -108,6 +110,48 @@ func NewComponentExtraArgs(opts util.ExtraOptionSlice, version semver.Version, f
 	return kubeadmExtraArgs, nil
 }
 
+func ParseFeatureArgs(featureGates string) (map[string]bool, string, error) {
+	kubeadmFeatureArgs := map[string]bool{}
+	componentFeatureArgs := ""
+	for _, s := range strings.Split(featureGates, ",") {
+		if len(s) == 0 {
+			continue
+		}
+
+		fg := strings.SplitN(s, "=", 2)
+		if len(fg) != 2 {
+			return nil, "", fmt.Errorf("missing value for key \"%v\"", s)
+		}
+
+		k := strings.TrimSpace(fg[0])
+		v := strings.TrimSpace(fg[1])
+
+		if !Supports(k) {
+			componentFeatureArgs = fmt.Sprintf("%s%s,", componentFeatureArgs, s)
+			continue
+		}
+
+		boolValue, err := strconv.ParseBool(v)
+		if err != nil {
+			return nil, "", errors.Wrapf(err, "failed to convert bool value \"%v\"", v)
+		}
+		kubeadmFeatureArgs[k] = boolValue
+	}
+	componentFeatureArgs = strings.TrimRight(componentFeatureArgs, ",")
+	return kubeadmFeatureArgs, componentFeatureArgs, nil
+}
+
+// Supports indicates whether a feature name is supported on the
+// feature gates for kubeadm
+func Supports(featureName string) bool {
+	for k := range features.InitFeatureGates {
+		if featureName == string(k) {
+			return true
+		}
+	}
+	return false
+}
+
 func ParseKubernetesVersion(version string) (semver.Version, error) {
 	// Strip leading 'v' prefix from version for semver parsing
 	v, err := semver.Make(version[1:])

pkg/minikube/bootstrapper/kubeadm/versions_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package kubeadm
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/blang/semver"
@@ -101,3 +102,55 @@ func TestParseKubernetesVersion(t *testing.T) {
 		t.Errorf("Expected: %s, Actual:%s", "1.8.0-alpha.5", version)
 	}
 }
+
+func TestParseFeatureArgs(t *testing.T) {
+	tests := []struct {
+		description                  string
+		featureGates                 string
+		expectedKubeadmFeatureArgs   map[string]bool
+		expectedComponentFeatureArgs string
+	}{
+		{
+			description:  "only kubeadm feature",
+			featureGates: "Auditing=true,SelfHosting=false",
+			expectedKubeadmFeatureArgs: map[string]bool{
+				"Auditing":    true,
+				"SelfHosting": false,
+			},
+			expectedComponentFeatureArgs: "",
+		},
+		{
+			description:                  "only component feature",
+			featureGates:                 "PodPriority=true,Accelerators=false",
+			expectedKubeadmFeatureArgs:   map[string]bool{},
+			expectedComponentFeatureArgs: "PodPriority=true,Accelerators=false",
+		},
+		{
+			description:  "between component and kubeadm feature",
+			featureGates: "Auditing=true,PodPriority=true,SelfHosting=false,Accelerators=false",
+			expectedKubeadmFeatureArgs: map[string]bool{
+				"Auditing":    true,
+				"SelfHosting": false,
+			},
+			expectedComponentFeatureArgs: "PodPriority=true,Accelerators=false",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+			kubeadm, component, err := ParseFeatureArgs(test.featureGates)
+
+			if err != nil {
+				t.Fatalf("Error parsing feature args: %s", err)
+			}
+
+			if !reflect.DeepEqual(kubeadm, test.expectedKubeadmFeatureArgs) {
+				t.Errorf("Kubeadm Actual: %v, Expected: %v", kubeadm, test.expectedKubeadmFeatureArgs)
+			}
+
+			if !reflect.DeepEqual(component, test.expectedComponentFeatureArgs) {
+				t.Errorf("Component Actual: %v, Expected: %v", component, test.expectedComponentFeatureArgs)
+			}
+		})
+	}
+}