[minikube]:windows node setup

cmd/minikube/cmd/node_add.go

@@ -17,6 +17,9 @@ limitations under the License.
 package cmd
 
 import (
+	"strings"
+
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
@@ -36,13 +39,35 @@ var (
 	cpNode              bool
 	workerNode          bool
 	deleteNodeOnFailure bool
+	osType              string
+
+	osTypeLong = "This flag should only be used when adding a windows node to a cluster.\n\n" +
+		"Specify the OS of the node to add in the format 'os=OS_TYPE,version=VERSION'.\n" +
+		"This means that the node to be added will be a Windows node and the version of Windows OS to use for that node is Windows Server 2022.\n" +
+		"Example: $ minikube node add --os='os=windows,version=2022'\n" +
+		"Valid options for OS_TYPE are: linux, windows. If not specified, the default value is linux.\n" +
+		"You do not need to specify the --os flag if you are adding a linux node."
 )
 
 var nodeAddCmd = &cobra.Command{
 	Use:   "add",
 	Short: "Adds a node to the given cluster.",
 	Long:  "Adds a node to the given cluster config, and starts it.",
 	Run: func(cmd *cobra.Command, _ []string) {
+
+		osType, windowsVersion, err := parseOSFlag(osType)
+		if err != nil {
+			exit.Message(reason.Usage, "{{.err}}", out.V{"err": err})
+		}
+
+		if err := validateOSandVersion(osType, windowsVersion); err != nil {
+			exit.Message(reason.Usage, "{{.err}}", out.V{"err": err})
+		}
+
+		if osType == "windows" && cpNode {
+			exit.Message(reason.Usage, "Windows node cannot be used as control-plane nodes.")
+		}
+
 		co := mustload.Healthy(ClusterFlagValue())
 		cc := co.Config
 
@@ -109,6 +134,42 @@ func init() {
 	nodeAddCmd.Flags().BoolVar(&cpNode, "control-plane", false, "If set, added node will become a control-plane. Defaults to false. Currently only supported for existing HA (multi-control plane) clusters.")
 	nodeAddCmd.Flags().BoolVar(&workerNode, "worker", true, "If set, added node will be available as worker. Defaults to true.")
 	nodeAddCmd.Flags().BoolVar(&deleteNodeOnFailure, "delete-on-failure", false, "If set, delete the current cluster if start fails and try again. Defaults to false.")
+	nodeAddCmd.Flags().StringVar(&osType, "os", "linux", osTypeLong)
 
 	nodeCmd.AddCommand(nodeAddCmd)
 }
+
+// parseOSFlag parses the --os flag value , 'os=OS_TYPE,version=VERSION', and returns the os type and version
+// For example, 'os=windows,version=2022' The output will be os: 'windows' and version: '2022' respectively
+func parseOSFlag(osFlagValue string) (string, string, error) {
+	// Remove all spaces from the input string
+	osFlagValue = strings.ReplaceAll(osFlagValue, " ", "")
+	parts := strings.Split(osFlagValue, ",")
+	osInfo := map[string]string{
+		"os":      "linux", // default value
+		"version": "",
+	}
+
+	for _, part := range parts {
+		kv := strings.Split(part, "=")
+		if len(kv) != 2 {
+			return "", "", errors.Errorf("Invalid format for --os flag: %s", osFlagValue)
+		}
+		osInfo[kv[0]] = kv[1]
+	}
+
+	// if os is specified to linux, set the version to empty string as it is not required
+	if osInfo["os"] == "linux" {
+		if osInfo["version"] != "" {
+			out.WarningT("Ignoring version flag for linux os. You do not need to specify the version for linux os.")
+		}
+		osInfo["version"] = ""
+	}
+
+	// if os is specified to windows and version is not specified, set the default version to 2022(Windows Server 2022)
+	if osInfo["os"] == "windows" && osInfo["version"] == "" {
+		osInfo["version"] = "2022"
+	}
+
+	return osInfo["os"], osInfo["version"], nil
+}

cmd/minikube/cmd/node_add_test.go

@@ -0,0 +1,134 @@
+/*
+Copyright 2024 The Kubernetes Authors All rights reserved.
+
+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 cmd
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestValidateOS(t *testing.T) {
+	tests := []struct {
+		osType   string
+		errorMsg string
+	}{
+		{"linux", ""},
+		{"windows", ""},
+		{"foo", "Invalid OS: foo. Valid OS are: linux, windows"},
+	}
+	for _, test := range tests {
+		t.Run(test.osType, func(t *testing.T) {
+			got := validateOS(test.osType)
+			gotError := ""
+			if got != nil {
+				gotError = got.Error()
+			}
+			if gotError != test.errorMsg {
+				t.Errorf("validateOS(osType=%v): got %v, expected %v", test.osType, got, test.errorMsg)
+			}
+		})
+	}
+}
+
+// TestParseOSFlag is the main test function for parseOSFlag
+func TestParseOSFlag(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		expectedOS  string
+		expectedVer string
+		expectedErr error
+	}{
+		{
+			name:        "Valid input with all fields",
+			input:       "os=windows,version=2019",
+			expectedOS:  "windows",
+			expectedVer: "2019",
+			expectedErr: nil,
+		},
+		{
+			name:        "Valid input with default version for windows",
+			input:       "os=windows",
+			expectedOS:  "windows",
+			expectedVer: "2022",
+			expectedErr: nil,
+		},
+		{
+			name:        "Valid input with linux and no version",
+			input:       "os=linux",
+			expectedOS:  "linux",
+			expectedVer: "",
+			expectedErr: nil,
+		},
+		{
+			name:        "Invalid input with missing version",
+			input:       "os=linux,version=",
+			expectedOS:  "linux",
+			expectedVer: "",
+			expectedErr: nil,
+		},
+		{
+			name:        "Invalid input with extra comma",
+			input:       "os=linux,version=,",
+			expectedOS:  "",
+			expectedVer: "",
+			expectedErr: errors.New("Invalid format for --os flag: os=linux,version=,"),
+		},
+		{
+			name:        "Invalid input with no key-value pair",
+			input:       "linux,version=2022",
+			expectedOS:  "",
+			expectedVer: "",
+			expectedErr: errors.New("Invalid format for --os flag: linux,version=2022"),
+		},
+		{
+			name:        "Valid input with extra spaces",
+			input:       "os=linux , version=latest",
+			expectedOS:  "linux",
+			expectedVer: "",
+			expectedErr: nil,
+		},
+		{
+			name:        "Valid input with capital letters in keys",
+			input:       "OS=linux,Version=2022",
+			expectedOS:  "linux",
+			expectedVer: "",
+			expectedErr: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotOS, gotVer, err := parseOSFlag(tt.input)
+
+			if tt.expectedErr != nil && (err == nil || err.Error() != tt.expectedErr.Error()) {
+				t.Errorf("Expected error %v, got %v", tt.expectedErr, err)
+			} else if tt.expectedErr == nil && err != nil {
+				t.Errorf("Expected no error, but got %v", err)
+			}
+
+			if gotOS != tt.expectedOS {
+				t.Errorf("Expected OS %s, got %s", tt.expectedOS, gotOS)
+			}
+
+			if gotVer != tt.expectedVer {
+				t.Errorf("Expected version %s, got %s", tt.expectedVer, gotVer)
+			}
+		})
+	}
+}

cmd/minikube/cmd/start.go

@@ -45,6 +45,7 @@ import (
 	gopshost "github.com/shirou/gopsutil/v3/host"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"golang.org/x/exp/maps"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 	"k8s.io/minikube/pkg/minikube/command"
@@ -355,6 +356,13 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing *
 		os.Exit(0)
 	}
 
+	// If preloadWindowsIso flag is true then cache the windows ISO
+	if viper.GetBool(preloadWindowsIso) {
+		if err := download.WindowsISO(viper.GetString(windowsNodeVersion)); err != nil {
+			return node.Starter{}, errors.Wrap(err, "Failed to cache Windows ISO")
+		}
+	}
+
 	if driver.IsVM(driverName) && !driver.IsSSH(driverName) {
 		url, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL))
 		if err != nil {
@@ -491,15 +499,36 @@ func startWithDriver(cmd *cobra.Command, starter node.Starter, existing *config.
 				KubernetesVersion: starter.Cfg.KubernetesConfig.KubernetesVersion,
 				ContainerRuntime:  starter.Cfg.KubernetesConfig.ContainerRuntime,
 				Worker:            true,
+				OS:                "linux",
 			}
 			if i < numCPNodes { // starter node is also counted as (primary) cp node
 				n.ControlPlane = true
 			}
 		}
 
+		out.Ln("") // extra newline for clarity on the command line
+		// 1st call
+		if err := node.Add(starter.Cfg, n, viper.GetBool(deleteOnFailure)); err != nil {
+			return nil, errors.Wrap(err, "adding linux node")
+		}
+	}
+
+	// start windows node. trigger windows node start only if windows node version is set at the time of minikube start
+	if cmd.Flags().Changed(windowsNodeVersion) {
+		// TODO: if windows node version is set to windows server 2022 then the windows node name should be minikube-ws2022
+		nodeName := node.Name(numNodes + 1)
+		n := config.Node{
+			Name:              nodeName,
+			Port:              starter.Cfg.APIServerPort,
+			KubernetesVersion: starter.Cfg.KubernetesConfig.KubernetesVersion,
+			ContainerRuntime:  starter.Cfg.KubernetesConfig.ContainerRuntime,
+			Worker:            true,
+			OS:                "windows",
+		}
+
 		out.Ln("") // extra newline for clarity on the command line
 		if err := node.Add(starter.Cfg, n, viper.GetBool(deleteOnFailure)); err != nil {
-			return nil, errors.Wrap(err, "adding node")
+			return nil, errors.Wrap(err, "adding windows node")
 		}
 	}
 
@@ -1303,6 +1332,16 @@ func validateFlags(cmd *cobra.Command, drvName string) { //nolint:gocyclo
 		validateCNI(cmd, viper.GetString(containerRuntime))
 	}
 
+	if cmd.Flags().Changed(windowsNodeVersion) {
+		if err := validateWindowsOSVersion(viper.GetString(windowsNodeVersion)); err != nil {
+			exit.Message(reason.Usage, "{{.err}}", out.V{"err": err})
+		}
+
+		// set preloadWindowsIso to true since we need to download the windows ISO file
+		viper.Set(preloadWindowsIso, true)
+
+	}
+
 	if cmd.Flags().Changed(staticIP) {
 		if err := validateStaticIP(viper.GetString(staticIP), drvName, viper.GetString(subnet)); err != nil {
 			exit.Message(reason.Usage, "{{.err}}", out.V{"err": err})
@@ -1424,6 +1463,45 @@ func validateDiskSize(diskSize string) error {
 	return nil
 }
 
+// validateWindowsOSVersion validates the supplied window server os version
+func validateWindowsOSVersion(osVersion string) error {
+	validOptions := node.ValidWindowsOSVersions()
+
+	if validOptions[osVersion] {
+		return nil
+	}
+
+	return errors.Errorf("Invalid Windows Server OS Version: %s. Valid OS version are: %s", osVersion, maps.Keys(validOptions))
+}
+
+// validateOS validates the supplied OS
+func validateOS(os string) error {
+	validOptions := node.ValidOS()
+
+	for _, validOS := range validOptions {
+		if os == validOS {
+			return nil
+		}
+	}
+
+	return errors.Errorf("Invalid OS: %s. Valid OS are: %s", os, strings.Join(validOptions, ", "))
+}
+
+// validateOSandVersion validates the supplied OS and version
+func validateOSandVersion(os, version string) error {
+
+	if err := validateOS(os); err != nil {
+		return err
+	}
+
+	if version != "" {
+		if err := validateWindowsOSVersion(version); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // validateRuntime validates the supplied runtime
 func validateRuntime(rtime string) error {
 	validOptions := cruntime.ValidRuntimes()

cmd/minikube/cmd/start_flags.go

@@ -118,6 +118,7 @@ const (
 	ha                      = "ha"
 	nodes                   = "nodes"
 	preload                 = "preload"
+	preloadWindowsIso       = "preload-windows-iso"
 	deleteOnFailure         = "delete-on-failure"
 	forceSystemd            = "force-systemd"
 	kicBaseImage            = "base-image"
@@ -144,6 +145,7 @@ const (
 	staticIP                = "static-ip"
 	gpus                    = "gpus"
 	autoPauseInterval       = "auto-pause-interval"
+	windowsNodeVersion      = "windows-node-version"
 )
 
 var (
@@ -194,6 +196,7 @@ func initMinikubeFlags() {
 	startCmd.Flags().Bool(ha, false, "Create Highly Available Multi-Control Plane Cluster with a minimum of three control-plane nodes that will also be marked for work.")
 	startCmd.Flags().IntP(nodes, "n", 1, "The total number of nodes to spin up. Defaults to 1.")
 	startCmd.Flags().Bool(preload, true, "If set, download tarball of preloaded images if available to improve start time. Defaults to true.")
+	startCmd.Flags().Bool(preloadWindowsIso, false, "If set, download the Windows ISO to improve start time of setting up a windows node. Defaults to false.")
 	startCmd.Flags().Bool(noKubernetes, false, "If set, minikube VM/container will start without starting or configuring Kubernetes. (only works on new clusters)")
 	startCmd.Flags().Bool(deleteOnFailure, false, "If set, delete the current cluster if start fails and try again. Defaults to false.")
 	startCmd.Flags().Bool(forceSystemd, false, "If set, force the container runtime to use systemd as cgroup manager. Defaults to false.")
@@ -208,6 +211,8 @@ func initMinikubeFlags() {
 	startCmd.Flags().String(staticIP, "", "Set a static IP for the minikube cluster, the IP must be: private, IPv4, and the last octet must be between 2 and 254, for example 192.168.200.200 (Docker and Podman drivers only)")
 	startCmd.Flags().StringP(gpus, "g", "", "Allow pods to use your NVIDIA GPUs. Options include: [all,nvidia] (Docker driver with Docker container-runtime only)")
 	startCmd.Flags().Duration(autoPauseInterval, time.Minute*1, "Duration of inactivity before the minikube VM is paused (default 1m0s)")
+	startCmd.Flags().String(windowsNodeVersion, constants.DefaultWindowsNodeVersion, "The version of Windows to use for the Windows node on a multi-node cluster (e.g., 2019, 2022). Defaults to Windows Server 2022")
+
 }
 
 // initKubernetesFlags inits the commandline flags for Kubernetes related options
@@ -586,6 +591,7 @@ func generateNewConfigFromFlags(cmd *cobra.Command, k8sVersion string, rtime str
 		SocketVMnetClientPath:   detect.SocketVMNetClientPath(),
 		SocketVMnetPath:         detect.SocketVMNetPath(),
 		StaticIP:                viper.GetString(staticIP),
+		WindowsNodeVersion:      viper.GetString(windowsNodeVersion),
 		KubernetesConfig: config.KubernetesConfig{
 			KubernetesVersion:      k8sVersion,
 			ClusterName:            ClusterFlagValue(),
@@ -837,6 +843,7 @@ func updateExistingConfigFromFlags(cmd *cobra.Command, existing *config.ClusterC
 	updateStringFromFlag(cmd, &cc.SocketVMnetClientPath, socketVMnetClientPath)
 	updateStringFromFlag(cmd, &cc.SocketVMnetPath, socketVMnetPath)
 	updateDurationFromFlag(cmd, &cc.AutoPauseInterval, autoPauseInterval)
+	updateStringFromFlag(cmd, &cc.WindowsNodeVersion, windowsNodeVersion)
 
 	if cmd.Flags().Changed(kubernetesVersion) {
 		kubeVer, err := getKubernetesVersion(existing)