added google drive

pkg/utils/balance.go

@@ -0,0 +1,18 @@
+package utils
+
+import "strings"
+
+var balance = ".balance"
+
+func IsBalance(str string) bool {
+	return strings.Contains(str, balance)
+}
+
+// GetActualMountPath remove balance suffix
+func GetActualMountPath(virtualPath string) string {
+	bIndex := strings.LastIndex(virtualPath, ".balance")
+	if bIndex != -1 {
+		virtualPath = virtualPath[:bIndex]
+	}
+	return virtualPath
+}

pkg/utils/bool.go

@@ -0,0 +1,5 @@
+package utils
+
+func IsBool(bs ...bool) bool {
+	return len(bs) > 0 && bs[0]
+}

pkg/utils/ctx.go

@@ -0,0 +1,14 @@
+package utils
+
+import (
+	"context"
+)
+
+func IsCanceled(ctx context.Context) bool {
+	select {
+	case <-ctx.Done():
+		return true
+	default:
+		return false
+	}
+}

pkg/utils/path.go

@@ -0,0 +1,81 @@
+package utils
+
+import (
+	"errors"
+	"net/url"
+	stdpath "path"
+	"strings"
+)
+
+// FixAndCleanPath
+// The upper layer of the root directory is still the root directory.
+// So ".." And "." will be cleared
+// for example
+// 1. ".." or "." => "/"
+// 2. "../..." or "./..." => "/..."
+// 3. "../.x." or "./.x." => "/.x."
+// 4. "x//\\y" = > "/z/x"
+func FixAndCleanPath(path string) string {
+	path = strings.ReplaceAll(path, "\\", "/")
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	return stdpath.Clean(path)
+}
+
+// PathAddSeparatorSuffix Add path '/' suffix
+// for example /root => /root/
+func PathAddSeparatorSuffix(path string) string {
+	if !strings.HasSuffix(path, "/") {
+		path = path + "/"
+	}
+	return path
+}
+
+// PathEqual judge path is equal
+func PathEqual(path1, path2 string) bool {
+	return FixAndCleanPath(path1) == FixAndCleanPath(path2)
+}
+
+func IsSubPath(path string, subPath string) bool {
+	path, subPath = FixAndCleanPath(path), FixAndCleanPath(subPath)
+	return path == subPath || strings.HasPrefix(subPath, PathAddSeparatorSuffix(path))
+}
+
+func Ext(path string) string {
+	ext := stdpath.Ext(path)
+	if strings.HasPrefix(ext, ".") {
+		return ext[1:]
+	}
+	return ext
+}
+
+func EncodePath(path string, all ...bool) string {
+	seg := strings.Split(path, "/")
+	toReplace := []struct {
+		Src string
+		Dst string
+	}{
+		{Src: "%", Dst: "%25"},
+		{"%", "%25"},
+		{"?", "%3F"},
+		{"#", "%23"},
+	}
+	for i := range seg {
+		if len(all) > 0 && all[0] {
+			seg[i] = url.PathEscape(seg[i])
+		} else {
+			for j := range toReplace {
+				seg[i] = strings.ReplaceAll(seg[i], toReplace[j].Src, toReplace[j].Dst)
+			}
+		}
+	}
+	return strings.Join(seg, "/")
+}
+
+func JoinBasePath(basePath, reqPath string) (string, error) {
+	if strings.HasSuffix(reqPath, "..") || strings.Contains(reqPath, "../") {
+		return "", errors.New("access using relative path is not allowed")
+	}
+	return stdpath.Join(FixAndCleanPath(basePath), FixAndCleanPath(reqPath)), nil
+}

pkg/utils/slice.go

@@ -0,0 +1,46 @@
+package utils
+
+// SliceEqual check if two slices are equal
+func SliceEqual[T comparable](a, b []T) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, v := range a {
+		if v != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// SliceContains check if slice contains element
+func SliceContains[T comparable](arr []T, v T) bool {
+	for _, vv := range arr {
+		if vv == v {
+			return true
+		}
+	}
+	return false
+}
+
+// SliceConvert convert slice to another type slice
+func SliceConvert[S any, D any](srcS []S, convert func(src S) (D, error)) ([]D, error) {
+	var res []D
+	for i := range srcS {
+		dst, err := convert(srcS[i])
+		if err != nil {
+			return nil, err
+		}
+		res = append(res, dst)
+	}
+	return res, nil
+}
+
+func MustSliceConvert[S any, D any](srcS []S, convert func(src S) D) []D {
+	var res []D
+	for i := range srcS {
+		dst := convert(srcS[i])
+		res = append(res, dst)
+	}
+	return res
+}