Merge pull request #62364 from dixudx/automated-cherry-pick-of-#62154-upstream-release-1.10

pkg/util/mount/BUILD

@@ -102,6 +102,7 @@ go_test(
     ] + select({
         "@io_bazel_rules_go//go/platform:linux": [
             "//vendor/github.com/golang/glog:go_default_library",
+            "//vendor/k8s.io/utils/exec:go_default_library",
         ],
         "@io_bazel_rules_go//go/platform:windows": [
             "//vendor/github.com/stretchr/testify/assert:go_default_library",

pkg/util/mount/mount.go

@@ -19,6 +19,7 @@ limitations under the License.
 package mount
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -337,3 +338,37 @@ func startsWithBackstep(rel string) bool {
 	// normalize to / and check for ../
 	return rel == ".." || strings.HasPrefix(filepath.ToSlash(rel), "../")
 }
+
+// getFileType checks for file/directory/socket and block/character devices
+func getFileType(pathname string) (FileType, error) {
+	var pathType FileType
+	info, err := os.Stat(pathname)
+	if os.IsNotExist(err) {
+		return pathType, fmt.Errorf("path %q does not exist", pathname)
+	}
+	// err in call to os.Stat
+	if err != nil {
+		return pathType, err
+	}
+
+	// checks whether the mode is the target mode
+	isSpecificMode := func(mode, targetMode os.FileMode) bool {
+		return mode&targetMode == targetMode
+	}
+
+	mode := info.Mode()
+	if mode.IsDir() {
+		return FileTypeDirectory, nil
+	} else if mode.IsRegular() {
+		return FileTypeFile, nil
+	} else if isSpecificMode(mode, os.ModeSocket) {
+		return FileTypeSocket, nil
+	} else if isSpecificMode(mode, os.ModeDevice) {
+		if isSpecificMode(mode, os.ModeCharDevice) {
+			return FileTypeCharDev, nil
+		}
+		return FileTypeBlockDev, nil
+	}
+
+	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
+}

pkg/util/mount/mount_linux.go

@@ -423,31 +423,7 @@ func (mounter *Mounter) MakeRShared(path string) error {
 }
 
 func (mounter *Mounter) GetFileType(pathname string) (FileType, error) {
-	var pathType FileType
-	finfo, err := os.Stat(pathname)
-	if os.IsNotExist(err) {
-		return pathType, fmt.Errorf("path %q does not exist", pathname)
-	}
-	// err in call to os.Stat
-	if err != nil {
-		return pathType, err
-	}
-
-	mode := finfo.Sys().(*syscall.Stat_t).Mode
-	switch mode & syscall.S_IFMT {
-	case syscall.S_IFSOCK:
-		return FileTypeSocket, nil
-	case syscall.S_IFBLK:
-		return FileTypeBlockDev, nil
-	case syscall.S_IFCHR:
-		return FileTypeCharDev, nil
-	case syscall.S_IFDIR:
-		return FileTypeDirectory, nil
-	case syscall.S_IFREG:
-		return FileTypeFile, nil
-	}
-
-	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
+	return getFileType(pathname)
 }
 
 func (mounter *Mounter) MakeDir(pathname string) error {

pkg/util/mount/mount_linux_test.go

@@ -25,10 +25,12 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"strconv"
+	"strings"
 	"syscall"
 	"testing"
 
-	"strconv"
+	"k8s.io/utils/exec"
 
 	"github.com/golang/glog"
 )
@@ -1181,7 +1183,7 @@ func TestBindSubPath(t *testing.T) {
 			expectError: false,
 		},
 		{
-			name: "subpath-mounting-unix-socket",
+			name: "mount-unix-socket",
 			prepare: func(base string) ([]string, string, string, error) {
 				volpath, subpathMount := getTestPaths(base)
 				mounts := []string{subpathMount}
@@ -1193,9 +1195,9 @@ func TestBindSubPath(t *testing.T) {
 					return nil, "", "", err
 				}
 
-				testSocketFile := filepath.Join(volpath, "mount_test.sock")
-				_, err := net.Listen("unix", testSocketFile)
-				return mounts, volpath, testSocketFile, err
+				socketFile, socketCreateError := createSocketFile(volpath)
+
+				return mounts, volpath, socketFile, socketCreateError
 			},
 			expectError: false,
 		},
@@ -1226,6 +1228,7 @@ func TestBindSubPath(t *testing.T) {
 		if err != nil {
 			t.Fatalf(err.Error())
 		}
+
 		mounts, volPath, subPath, err := test.prepare(base)
 		if err != nil {
 			os.RemoveAll(base)
@@ -1476,29 +1479,29 @@ func TestSafeOpen(t *testing.T) {
 			true,
 		},
 		{
-			"mounting-unix-socket",
+			"mount-unix-socket",
 			func(base string) error {
-				testSocketFile := filepath.Join(base, "mount_test.sock")
-				_, err := net.Listen("unix", testSocketFile)
-				if err != nil {
-					return fmt.Errorf("Error preparing socket file %s with %v", testSocketFile, err)
+				socketFile, socketError := createSocketFile(base)
+
+				if socketError != nil {
+					return fmt.Errorf("Error preparing socket file %s with %v", socketFile, socketError)
 				}
 				return nil
 			},
-			"mount_test.sock",
+			"mt.sock",
 			false,
 		},
 		{
 			"mounting-unix-socket-in-middle",
 			func(base string) error {
-				testSocketFile := filepath.Join(base, "mount_test.sock")
-				_, err := net.Listen("unix", testSocketFile)
-				if err != nil {
-					return fmt.Errorf("Error preparing socket file %s with %v", testSocketFile, err)
+				testSocketFile, socketError := createSocketFile(base)
+
+				if socketError != nil {
+					return fmt.Errorf("Error preparing socket file %s with %v", testSocketFile, socketError)
 				}
 				return nil
 			},
-			"mount_test.sock/bar",
+			"mt.sock/bar",
 			true,
 		},
 	}
@@ -1509,6 +1512,7 @@ func TestSafeOpen(t *testing.T) {
 		if err != nil {
 			t.Fatalf(err.Error())
 		}
+
 		test.prepare(base)
 		pathToCreate := filepath.Join(base, test.path)
 		fd, err := doSafeOpen(pathToCreate, base)
@@ -1527,6 +1531,25 @@ func TestSafeOpen(t *testing.T) {
 	}
 }
 
+func createSocketFile(socketDir string) (string, error) {
+	testSocketFile := filepath.Join(socketDir, "mt.sock")
+
+	// Switch to volume path and create the socket file
+	// socket file can not have length of more than 108 character
+	// and hence we must use relative path
+	oldDir, _ := os.Getwd()
+
+	err := os.Chdir(socketDir)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		os.Chdir(oldDir)
+	}()
+	_, socketCreateError := net.Listen("unix", "mt.sock")
+	return testSocketFile, socketCreateError
+}
+
 func TestFindExistingPrefix(t *testing.T) {
 	defaultPerm := os.FileMode(0750)
 	tests := []struct {
@@ -1659,3 +1682,110 @@ func TestFindExistingPrefix(t *testing.T) {
 		os.RemoveAll(base)
 	}
 }
+
+func TestGetFileType(t *testing.T) {
+	mounter := Mounter{"fake/path", false}
+
+	testCase := []struct {
+		name         string
+		expectedType FileType
+		setUp        func() (string, string, error)
+	}{
+		{
+			"Directory Test",
+			FileTypeDirectory,
+			func() (string, string, error) {
+				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
+				return tempDir, tempDir, err
+			},
+		},
+		{
+			"File Test",
+			FileTypeFile,
+			func() (string, string, error) {
+				tempFile, err := ioutil.TempFile("", "test-get-filetype")
+				if err != nil {
+					return "", "", err
+				}
+				tempFile.Close()
+				return tempFile.Name(), tempFile.Name(), nil
+			},
+		},
+		{
+			"Socket Test",
+			FileTypeSocket,
+			func() (string, string, error) {
+				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
+				if err != nil {
+					return "", "", err
+				}
+				tempSocketFile, err := createSocketFile(tempDir)
+				return tempSocketFile, tempDir, err
+			},
+		},
+		{
+			"Block Device Test",
+			FileTypeBlockDev,
+			func() (string, string, error) {
+				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
+				if err != nil {
+					return "", "", err
+				}
+
+				tempBlockFile := filepath.Join(tempDir, "test_blk_dev")
+				outputBytes, err := exec.New().Command("mknod", tempBlockFile, "b", "89", "1").CombinedOutput()
+				if err != nil {
+					err = fmt.Errorf("%v: %s ", err, outputBytes)
+				}
+				return tempBlockFile, tempDir, err
+			},
+		},
+		{
+			"Character Device Test",
+			FileTypeCharDev,
+			func() (string, string, error) {
+				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
+				if err != nil {
+					return "", "", err
+				}
+
+				tempCharFile := filepath.Join(tempDir, "test_char_dev")
+				outputBytes, err := exec.New().Command("mknod", tempCharFile, "c", "89", "1").CombinedOutput()
+				if err != nil {
+					err = fmt.Errorf("%v: %s ", err, outputBytes)
+				}
+				return tempCharFile, tempDir, err
+			},
+		},
+	}
+
+	for idx, tc := range testCase {
+		path, cleanUpPath, err := tc.setUp()
+		if err != nil {
+			// Locally passed, but upstream CI is not friendly to create such device files
+			// Leave "Operation not permitted" out, which can be covered in an e2e test
+			if isOperationNotPermittedError(err) {
+				continue
+			}
+			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
+		}
+		if len(cleanUpPath) > 0 {
+			defer os.RemoveAll(cleanUpPath)
+		}
+
+		fileType, err := mounter.GetFileType(path)
+		if err != nil {
+			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
+		}
+		if fileType != tc.expectedType {
+			t.Fatalf("[%d-%s] expected %s, but got %s", idx, tc.name, tc.expectedType, fileType)
+		}
+	}
+}
+
+func isOperationNotPermittedError(err error) bool {
+	if strings.Contains(err.Error(), "Operation not permitted") {
+		return true
+	}
+	return false
+}

pkg/util/mount/mount_windows.go

@@ -201,31 +201,7 @@ func (mounter *Mounter) MakeRShared(path string) error {
 
 // GetFileType checks for sockets/block/character devices
 func (mounter *Mounter) GetFileType(pathname string) (FileType, error) {
-	var pathType FileType
-	info, err := os.Stat(pathname)
-	if os.IsNotExist(err) {
-		return pathType, fmt.Errorf("path %q does not exist", pathname)
-	}
-	// err in call to os.Stat
-	if err != nil {
-		return pathType, err
-	}
-
-	mode := info.Sys().(*syscall.Win32FileAttributeData).FileAttributes
-	switch mode & syscall.S_IFMT {
-	case syscall.S_IFSOCK:
-		return FileTypeSocket, nil
-	case syscall.S_IFBLK:
-		return FileTypeBlockDev, nil
-	case syscall.S_IFCHR:
-		return FileTypeCharDev, nil
-	case syscall.S_IFDIR:
-		return FileTypeDirectory, nil
-	case syscall.S_IFREG:
-		return FileTypeFile, nil
-	}
-
-	return pathType, fmt.Errorf("only recognise file, directory, socket, block device and character device")
+	return getFileType(pathname)
 }
 
 // MakeFile creates a new directory

pkg/util/mount/mount_windows_test.go

@@ -20,6 +20,7 @@ package mount
 
 import (
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -551,3 +552,52 @@ func TestPathWithinBase(t *testing.T) {
 			test.fullPath, test.basePath, result, test.expectedResult)
 	}
 }
+
+func TestGetFileType(t *testing.T) {
+	mounter := New("fake/path")
+
+	testCase := []struct {
+		name         string
+		expectedType FileType
+		setUp        func() (string, string, error)
+	}{
+		{
+			"Directory Test",
+			FileTypeDirectory,
+			func() (string, string, error) {
+				tempDir, err := ioutil.TempDir("", "test-get-filetype-")
+				return tempDir, tempDir, err
+			},
+		},
+		{
+			"File Test",
+			FileTypeFile,
+			func() (string, string, error) {
+				tempFile, err := ioutil.TempFile("", "test-get-filetype")
+				if err != nil {
+					return "", "", err
+				}
+				tempFile.Close()
+				return tempFile.Name(), tempFile.Name(), nil
+			},
+		},
+	}
+
+	for idx, tc := range testCase {
+		path, cleanUpPath, err := tc.setUp()
+		if err != nil {
+			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
+		}
+		if len(cleanUpPath) > 0 {
+			defer os.RemoveAll(cleanUpPath)
+		}
+
+		fileType, err := mounter.GetFileType(path)
+		if err != nil {
+			t.Fatalf("[%d-%s] unexpected error : %v", idx, tc.name, err)
+		}
+		if fileType != tc.expectedType {
+			t.Fatalf("[%d-%s] expected %s, but got %s", idx, tc.name, tc.expectedType, fileType)
+		}
+	}
+}