Initial commit, lifted from CeePee

Author: Matt Allen

fileinfo.go

@@ -0,0 +1,48 @@
+package fs
+
+import "fmt"
+
+type FileList struct {
+	path  string
+	files []string
+}
+
+type FileInfo struct {
+	FileName string `json:"file_name"`
+	Folder   string `json:"folder"`
+	FullPath string `json:"full_path"`
+	Size     uint64 `json:"file_size"`
+}
+
+func ScanDirectory(path string) FileList {
+	return FileList{path, listFolder(path)}
+}
+
+func (f *FileList) GetList() []string {
+	return f.files
+}
+
+func (f *FileList) Enrich(lock *FileMove) []FileInfo {
+	enrd := []FileInfo{}
+	for _, i := range f.files {
+		fullPath := f.prefixPath(i)
+		if lock.IsLocked(fullPath) {
+			continue
+		}
+		size, err := fileSize(fullPath)
+		if err != nil {
+			size = 0
+		}
+		enrd = append(enrd, FileInfo{
+			getFileNameFromPath(i),
+			getFolderFromPath(i),
+			fullPath,
+			size,
+		})
+	}
+	return enrd
+}
+
+func (f *FileList) prefixPath(p string) string {
+	return fmt.Sprintf("%s/%s", f.path, p)
+}

folders.go

@@ -0,0 +1,85 @@
+package fs
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func getFolderFromPath(p string) string {
+	split := strings.Split(p, "/")
+	return strings.Join(split[:len(split)-1], "/")
+}
+
+func getFileNameFromPath(p string) string {
+	split := strings.Split(p, "/")
+	return strings.Join(split[len(split)-1:], "/")
+}
+
+// List folders within a given directory
+func listFolder(f string) []string {
+	all := []string{}
+	_ = filepath.Walk(f, func(path string, info os.FileInfo, err error) error {
+		if err == nil {
+			if !info.IsDir() {
+				all = append(all, substring(path, len(f)+1))
+			}
+		}
+		return err
+	})
+	return all
+}
+
+func substring(s string, i int) string {
+	r := []rune(s)
+	return string(r[i:len(r)])
+}
+
+// Move a file from one location to another
+func moveFile(s, d string) error {
+	// Firstly, try renaming it. This will fail if the files are on different partitions.
+	err := os.Rename(s, d)
+	// If that fails then we need to make a copy of the file, then delete the existing one.
+	if err != nil {
+		// When copying, it could take a very long time!
+		in, err := os.Open(s)
+		if err != nil {
+			return err
+		}
+		defer in.Close()
+		out, err := os.Create(d)
+		if err != nil {
+			return err
+		}
+		defer func() {
+			cerr := out.Close()
+			if err == nil {
+				err = cerr
+			}
+		}()
+		if _, err = io.Copy(out, in); err != nil {
+			return err
+		}
+		err = out.Sync()
+		// And then delete the existing file
+		return deleteFile(s)
+	}
+	return err
+}
+
+func deleteFile(p string) error {
+	return os.Remove(p)
+}
+
+func fileSize(p string) (uint64, error) {
+	in, err := os.Open(p)
+	if err != nil {
+		return 0, err
+	}
+	fi, err := in.Stat()
+	if err != nil {
+		return 0, err
+	}
+	return uint64(fi.Size()), err
+}

folders_test.go

@@ -0,0 +1,14 @@
+package fs
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestListDirectory(t *testing.T) {
+	dir := listFolder("tests")
+	assert.Equal(t, 2, len(dir))
+	assert.Contains(t, dir, "file.txt")
+	assert.Contains(t, dir, "subfolder/subfile.txt")
+}

lock.go

@@ -0,0 +1,77 @@
+package fs
+
+import (
+	"errors"
+	"fmt"
+	"github.com/minio/minio/pkg/disk"
+	"log"
+)
+
+type FileMove struct {
+	locks map[string]uint64
+}
+
+func CreateNewLock() *FileMove {
+	return &FileMove{make(map[string]uint64)}
+}
+
+func (f *FileMove) Move(from, to string) {
+	size, err := fileSize(from)
+	if err != nil {
+		f.locks[from] = 0
+	} else {
+		f.locks[from] = size
+	}
+	_ = moveFile(from, to)
+	delete(f.locks, from)
+	log.Println(fmt.Sprintf("Moving of %s is complete", from))
+}
+
+func (f *FileMove) IsLocked(p string) bool {
+	_, exists := f.locks[p]
+	return exists
+}
+
+func (f *FileMove) CanMove(from, to string) error {
+	log.Println(fmt.Sprintf("Requesting to move %s to %s", from, to))
+	if !isValidFolderPath(from) {
+		return errors.New("the source is not a valid file path")
+	}
+	if !isValidFolderPath(to) {
+		return errors.New("the destination is not a valid file path")
+	}
+	if f.IsLocked(from) {
+		return errors.New("this file is already being moved and cannot be changed")
+	}
+	size, sErr := fileSize(from)
+	if sErr != nil {
+		return sErr
+	}
+	log.Println("Checking remaining space at "+getFolderFromPath(to))
+	left, lErr := remainingSpace(getFolderFromPath(to))
+	if lErr != nil {
+		return lErr
+	}
+	log.Println(fmt.Sprintf("File size: %d, remaining: %d", size, left))
+	if size > left {
+		return errors.New("not enough space at the destination to move this file")
+	}
+	// TODO Also check write permissions in destination directory
+	return nil
+}
+
+func (f *FileMove) CanDelete(from string) bool {
+	return isValidFolderPath(from) && !f.IsLocked(from)
+}
+
+func (f *FileMove) Delete(from string) error {
+	return deleteFile(from)
+}
+
+func remainingSpace(p string) (uint64, error) {
+	di, err := disk.GetInfo(p)
+	if err != nil {
+		return 0, err
+	}
+	return di.Free, err
+}

tests/file.txt

@@ -0,0 +1,20 @@
+package fs
+
+import (
+	"os"
+	"regexp"
+)
+
+func isValidFileName(s string) bool {
+	m, err := regexp.MatchString("^[^<>:;,?\"*|/]+$", s)
+	return err == nil && m
+}
+
+func doesFileExist(s, p string) bool {
+	_, err := os.Stat(s)
+	return !os.IsNotExist(err)
+}
+
+func isValidFolderPath(s string) bool {
+	return true
+}

tests/subfolder/subfile.txt

@@ -0,0 +1,17 @@
+package fs
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidFileName(t *testing.T) {
+	assert.True(t, isValidFileName("filename.txt"))
+	assert.False(t, isValidFileName("<.txt"))
+}
+
+func TestDoesFileExist(t *testing.T) {
+	assert.True(t, doesFileExist("lock.go", "."))
+	assert.False(t, doesFileExist("<.txt", "."))
+}