WIP: Support GCEPD driver for Windows

WIP

Author: jingxu97

cmd/main.go

@@ -90,7 +90,10 @@ func handle() {
 	//Initialize requirements for the node service
 	var nodeServer *driver.GCENodeServer
 	if *runNodeService {
-		mounter := mountmanager.NewSafeMounter()
+		mounter, err := mountmanager.NewSafeMounter()
+		if err != nil {
+			klog.Fatalln("Failed to get safe mounter. Error: %v", err)
+		}
 		deviceUtils := mountmanager.NewDeviceUtils()
 		statter := mountmanager.NewStatter()
 		meta, err := metadataservice.NewMetadataService()

pkg/gce-pd-csi-driver/node.go

@@ -17,6 +17,7 @@ package gceGCEDriver
 import (
 	"fmt"
 	"os"
+	"runtime"
 	"strconv"
 	"strings"
 
@@ -57,10 +58,20 @@ var _ csi.NodeServer = &GCENodeServer{}
 // node boot disk is considered an attachable disk so effective attach limit is
 // one less.
 const (
-	volumeLimitSmall int64 = 15
-	volumeLimitBig   int64 = 127
+	volumeLimitSmall     int64 = 15
+	volumeLimitBig       int64 = 127
+	defaultLinuxFsType         = "ext4"
+	defaultWindowsFsType       = "ntfs"
 )
 
+func getDefaultFsType() string {
+	if runtime.GOOS == "windows" {
+		return defaultWindowsFsType
+	} else {
+		return defaultLinuxFsType
+	}
+}
+
 func (ns *GCENodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error) {
 	// Validate Arguments
 	targetPath := req.GetTargetPath()
@@ -129,10 +140,12 @@ func (ns *GCENodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePub
 		}
 
 		sourcePath = stagingTargetPath
-
-		if err := os.MkdirAll(targetPath, 0750); err != nil {
-			return nil, status.Error(codes.Internal, fmt.Sprintf("mkdir failed on disk %s (%v)", targetPath, err))
-		}
+		/*if runtime.GOOS != "windows" {
+			if err := os.MkdirAll(targetPath, 0750); err != nil {
+				return nil, status.Error(codes.Internal, fmt.Sprintf("mkdir failed on disk %s (%v)", targetPath, err))
+			}
+		}*/
+		preparePublishPath(targetPath, ns.Mounter)
 	} else if blk := volumeCapability.GetBlock(); blk != nil {
 		klog.V(4).Infof("NodePublishVolume with block volume mode")
 
@@ -218,11 +231,9 @@ func (ns *GCENodeServer) NodeUnpublishVolume(ctx context.Context, req *csi.NodeU
 	}
 	defer ns.volumeLocks.Release(volumeID)
 
-	err := mount.CleanupMountPoint(targetPath, ns.Mounter.Interface, false /* bind mount */)
-	if err != nil {
+	if err := cleanupPublishPath(targetPath, ns.Mounter); err != nil {
 		return nil, status.Error(codes.Internal, fmt.Sprintf("Unmount failed: %v\nUnmounting arguments: %s\n", err, targetPath))
 	}
-
 	klog.V(4).Infof("NodeUnpublishVolume succeded on %v from %s", volumeID, targetPath)
 	return &csi.NodeUnpublishVolumeResponse{}, nil
 }
@@ -265,43 +276,51 @@ func (ns *GCENodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStage
 		partition = part
 	}
 
-	devicePath, err := ns.getDevicePath(volumeID, partition)
+	deviceName, err := common.GetDeviceName(volumeKey)
+	if err != nil {
+		return nil, fmt.Errorf("error getting device name: %v", err)
+	}
+
+	devicePath, err := GetDevicePath(ns, deviceName, partition, volumeKey.Name, ns.Mounter)
+	//devicePath, err := ns.getDevicePath(volumeID, partition)
+
 	if err != nil {
 		return nil, status.Error(codes.Internal, fmt.Sprintf("Error when getting device path: %v", err))
 	}
 
 	klog.V(4).Infof("Successfully found attached GCE PD %q at device path %s.", volumeKey.Name, devicePath)
 
-	// Part 2: Check if mount already exists at targetpath
-	notMnt, err := ns.Mounter.Interface.IsLikelyNotMountPoint(stagingTargetPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			if err := os.MkdirAll(stagingTargetPath, 0750); err != nil {
-				return nil, status.Error(codes.Internal, fmt.Sprintf("Failed to create directory (%q): %v", stagingTargetPath, err))
+	if runtime.GOOS != "windows" {
+		// Part 2: Check if mount already exists at targetpath
+		notMnt, err := ns.Mounter.Interface.IsLikelyNotMountPoint(stagingTargetPath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				if err := os.MkdirAll(stagingTargetPath, 0750); err != nil {
+					return nil, status.Error(codes.Internal, fmt.Sprintf("Failed to create directory (%q): %v", stagingTargetPath, err))
+				}
+				notMnt = true
+			} else {
+				return nil, status.Error(codes.Internal, fmt.Sprintf("Unknown error when checking mount point (%q): %v", stagingTargetPath, err))
 			}
-			notMnt = true
-		} else {
-			return nil, status.Error(codes.Internal, fmt.Sprintf("Unknown error when checking mount point (%q): %v", stagingTargetPath, err))
 		}
-	}
 
-	if !notMnt {
-		// TODO(#95): Check who is mounted here. No error if its us
-		/*
-			1) Target Path MUST be the vol referenced by vol ID
-			2) VolumeCapability MUST match
-			3) Readonly MUST match
+		if !notMnt {
+			// TODO(#95): Check who is mounted here. No error if its us
+			/*
+				1) Target Path MUST be the vol referenced by vol ID
+				2) VolumeCapability MUST match
+				3) Readonly MUST match
 
-		*/
+			*/
 
-		klog.V(4).Infof("NodeStageVolume succeded on %v to %s, mount already exists.", volumeID, stagingTargetPath)
-		return &csi.NodeStageVolumeResponse{}, nil
+			klog.V(4).Infof("NodeStageVolume succeded on %v to %s, mount already exists.", volumeID, stagingTargetPath)
+			return &csi.NodeStageVolumeResponse{}, nil
 
+		}
 	}
-
 	// Part 3: Mount device to stagingTargetPath
-	// Default fstype is ext4
-	fstype := "ext4"
+	fstype := getDefaultFsType()
+
 	options := []string{}
 	if mnt := volumeCapability.GetMount(); mnt != nil {
 		if mnt.FsType != "" {
@@ -316,7 +335,8 @@ func (ns *GCENodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStage
 		return &csi.NodeStageVolumeResponse{}, nil
 	}
 
-	err = ns.Mounter.FormatAndMount(devicePath, stagingTargetPath, fstype, options)
+	//err = ns.Mounter.FormatAndMount(devicePath, stagingTargetPath, fstype, options)
+	err = FormatAndMount(devicePath, stagingTargetPath, fstype, options, ns.Mounter)
 	if err != nil {
 		return nil, status.Error(codes.Internal,
 			fmt.Sprintf("Failed to format and mount device from (%q) to (%q) with fstype (%q) and options (%q): %v",
@@ -343,9 +363,8 @@ func (ns *GCENodeServer) NodeUnstageVolume(ctx context.Context, req *csi.NodeUns
 	}
 	defer ns.volumeLocks.Release(volumeID)
 
-	err := mount.CleanupMountPoint(stagingTargetPath, ns.Mounter.Interface, false /* bind mount */)
-	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("NodeUnstageVolume failed to unmount at path %s: %v", stagingTargetPath, err))
+	if err := cleanupPublishPath(stagingTargetPath, ns.Mounter); err != nil {
+		return nil, status.Error(codes.Internal, fmt.Sprintf("NodeUnstageVolume failed: %v\nUnmounting arguments: %s\n", err, stagingTargetPath))
 	}
 
 	klog.V(4).Infof("NodeUnstageVolume succeded on %v from %s", volumeID, stagingTargetPath)

pkg/gce-pd-csi-driver/utils_linux.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2020 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.
+*/
+
+// +build !windows
+
+package gceGCEDriver
+
+import (
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"k8s.io/utils/mount"
+)
+
+func GetDevicePath(ns *GCENodeServer, deviceName string, partition string, volumeKey string) (string, error) {
+	devicePaths := ns.DeviceUtils.GetDiskByIdPaths(deviceName, partition)
+	devicePath, err := ns.DeviceUtils.VerifyDevicePath(devicePaths, volumeKey)
+	if err != nil {
+		return "", status.Error(codes.Internal, fmt.Sprintf("Error verifying GCE PD (%q) is attached: %v", volumeKey, err))
+	}
+	if devicePath == "" {
+		return "", status.Error(codes.Internal, fmt.Sprintf("Unable to find device path out of attempted paths: %v", devicePaths))
+	}
+	return devicePath, nil
+}
+
+/*func FormatAndMount(ns *GCENodeServer, source string, target string, fstype string, options []string) error {
+	return ns.Mounter.FormatAndMount(source, target, fstype, options)
+}*/
+
+func FormatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
+	return m.FormatAndMount(source, target, fstype, options)
+}
+
+func preparePublishPath(path string, m *mount.SafeFormatAndMount) error {
+	return nil
+}
+
+func cleanupPublishPath(path string, m *mount.SafeFormatAndMount) error {
+	return mount.CleanupMountPoint(path, m, false /* bind mount */)
+}

pkg/gce-pd-csi-driver/utils_windows.go

@@ -0,0 +1,78 @@
+/*
+Copyright 2020 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.
+*/
+
+// +build windows
+
+package gceGCEDriver
+
+import (
+	//"encoding/json"
+	//"errors"
+	"fmt"
+	"os/exec"
+	//"strconv"
+	//"strings"
+	//winutils "github.com/ddebroy/csi-proxy/pkg/api/v1alpha1"
+	//"google.golang.org/grpc/codes"
+	//"google.golang.org/grpc/status"
+	"k8s.io/klog"
+	"k8s.io/utils/mount"
+	mounter "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/mount-manager"
+)
+
+func FormatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
+	proxy, ok := m.Interface.(*mounter.CSIProxyMounter)
+	if !ok {
+		return fmt.Errorf("could not cast to csi proxy class")
+	}
+	return proxy.FormatAndMount(source, target, fstype, options)
+}
+
+func preparePublishPath(path string, m *mount.SafeFormatAndMount) error {
+	proxy, ok := m.Interface.(*mounter.CSIProxyMounter)
+	if !ok {
+		return fmt.Errorf("could not cast to csi proxy class")
+	}
+	exists, err := proxy.ExistsPath(path)
+	if err != nil {
+		return err
+	}
+	if exists {
+		return proxy.Unmount(path)
+	}
+	return nil
+}
+
+func cleanupPublishPath(path string, m *mount.SafeFormatAndMount) error {
+	proxy, ok := m.Interface.(*mounter.CSIProxyMounter)
+	if !ok {
+		return fmt.Errorf("could not cast to csi proxy class")
+	}
+	return proxy.Unmount(path)
+}
+
+// search Windows disk number by LUN
+func GetDevicePath(ns *GCENodeServer, deviceName string, partition string, volumeKey string, m *mount.SafeFormatAndMount) (string, error) {
+	proxy, ok := m.Interface.(*mounter.CSIProxyMounter)
+	if !ok {
+		return "", fmt.Errorf("could not cast to csi proxy class")
+	}
+	return proxy.GetDevicePath(deviceName, partition, volumeKey)
+}
+
+func runExec(cmd string) ([]byte, error) {
+	klog.V(5).Infof("Running command: %s", cmd)
+	out, err := exec.Command("powershell", "/c", cmd).CombinedOutput()
+	klog.V(5).Infof("Result: %s. Len: %d. Error: %v.", string(out), len(string(out)), err)
+	return out, err
+}

pkg/mount-manager/safe-mounter.go renamed to pkg/mount-manager/safe-mounter_linux.go

@@ -1,3 +1,5 @@
+// +build linux
+
 /*
 Copyright 2018 The Kubernetes Authors.
 
@@ -19,12 +21,12 @@ import (
 	"k8s.io/utils/mount"
 )
 
-func NewSafeMounter() *mount.SafeFormatAndMount {
+func NewSafeMounter() (*mount.SafeFormatAndMount, error) {
 	realMounter := mount.New("")
 	realExec := exec.New()
 	return &mount.SafeFormatAndMount{
 		Interface: realMounter,
 		Exec:      realExec,
-	}
+	}, nil
 
 }