5605e34f7b
In this commit
f4c40bf79d
mount: add --devname to set the device name sent to FUSE for mount display
The --devname parameter was added. However it was soon noticed that
attempting to mount via the rc gave this error:
mount helper error: fusermount: unknown option 'fsname'
mount FAILED: fusermount: exit status 1
This was because the DeviceName (and VolumeName) parameter was never
being initialised when the mount was called via the rc.
The fix for this was to refactor the rc interface so it called the
same Mount method as the command line mount which initialised the
DeviceName and VolumeName parameters properly.
This also fixes the cmd/mount tests which were breaking in the same
way but since they aren't normally run on the CI we didn't notice.
Fixes #6044
474 lines
12 KiB
Go
474 lines
12 KiB
Go
// Test suite for rclonefs
|
|
|
|
package vfstest
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"reflect"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
_ "github.com/rclone/rclone/backend/all" // import all the backends
|
|
"github.com/rclone/rclone/cmd/mountlib"
|
|
"github.com/rclone/rclone/fs"
|
|
"github.com/rclone/rclone/fs/walk"
|
|
"github.com/rclone/rclone/fstest"
|
|
"github.com/rclone/rclone/lib/file"
|
|
"github.com/rclone/rclone/vfs"
|
|
"github.com/rclone/rclone/vfs/vfscommon"
|
|
"github.com/rclone/rclone/vfs/vfsflags"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
const (
|
|
waitForWritersDelay = 30 * time.Second // time to wait for existing writers
|
|
)
|
|
|
|
var (
|
|
mountFn mountlib.MountFn
|
|
)
|
|
|
|
// RunTests runs all the tests against all the VFS cache modes
|
|
//
|
|
// If useVFS is set then it runs the tests against a VFS rather than amount
|
|
func RunTests(t *testing.T, useVFS bool, fn mountlib.MountFn) {
|
|
mountFn = fn
|
|
flag.Parse()
|
|
tests := []struct {
|
|
cacheMode vfscommon.CacheMode
|
|
writeBack time.Duration
|
|
}{
|
|
{cacheMode: vfscommon.CacheModeOff},
|
|
{cacheMode: vfscommon.CacheModeMinimal},
|
|
{cacheMode: vfscommon.CacheModeWrites},
|
|
{cacheMode: vfscommon.CacheModeFull},
|
|
{cacheMode: vfscommon.CacheModeFull, writeBack: 100 * time.Millisecond},
|
|
}
|
|
run = newRun(useVFS)
|
|
for _, test := range tests {
|
|
run.cacheMode(test.cacheMode, test.writeBack)
|
|
what := fmt.Sprintf("CacheMode=%v", test.cacheMode)
|
|
if test.writeBack > 0 {
|
|
what += fmt.Sprintf(",WriteBack=%v", test.writeBack)
|
|
}
|
|
log.Printf("Starting test run with %s", what)
|
|
ok := t.Run(what, func(t *testing.T) {
|
|
t.Run("TestTouchAndDelete", TestTouchAndDelete)
|
|
t.Run("TestRenameOpenHandle", TestRenameOpenHandle)
|
|
t.Run("TestDirLs", TestDirLs)
|
|
t.Run("TestDirCreateAndRemoveDir", TestDirCreateAndRemoveDir)
|
|
t.Run("TestDirCreateAndRemoveFile", TestDirCreateAndRemoveFile)
|
|
t.Run("TestDirRenameFile", TestDirRenameFile)
|
|
t.Run("TestDirRenameEmptyDir", TestDirRenameEmptyDir)
|
|
t.Run("TestDirRenameFullDir", TestDirRenameFullDir)
|
|
t.Run("TestDirModTime", TestDirModTime)
|
|
t.Run("TestDirCacheFlush", TestDirCacheFlush)
|
|
t.Run("TestDirCacheFlushOnDirRename", TestDirCacheFlushOnDirRename)
|
|
t.Run("TestFileModTime", TestFileModTime)
|
|
t.Run("TestFileModTimeWithOpenWriters", TestFileModTimeWithOpenWriters)
|
|
t.Run("TestMount", TestMount)
|
|
t.Run("TestRoot", TestRoot)
|
|
t.Run("TestReadByByte", TestReadByByte)
|
|
t.Run("TestReadChecksum", TestReadChecksum)
|
|
t.Run("TestReadFileDoubleClose", TestReadFileDoubleClose)
|
|
t.Run("TestReadSeek", TestReadSeek)
|
|
t.Run("TestWriteFileNoWrite", TestWriteFileNoWrite)
|
|
t.Run("TestWriteFileWrite", TestWriteFileWrite)
|
|
t.Run("TestWriteFileOverwrite", TestWriteFileOverwrite)
|
|
t.Run("TestWriteFileDoubleClose", TestWriteFileDoubleClose)
|
|
t.Run("TestWriteFileFsync", TestWriteFileFsync)
|
|
t.Run("TestWriteFileDup", TestWriteFileDup)
|
|
t.Run("TestWriteFileAppend", TestWriteFileAppend)
|
|
})
|
|
log.Printf("Finished test run with %s (ok=%v)", what, ok)
|
|
if !ok {
|
|
break
|
|
}
|
|
}
|
|
run.Finalise()
|
|
}
|
|
|
|
// Run holds the remotes for a test run
|
|
type Run struct {
|
|
os Oser
|
|
vfs *vfs.VFS
|
|
useVFS bool // set if we are testing a VFS not a mount
|
|
mnt *mountlib.MountPoint
|
|
mountPath string
|
|
fremote fs.Fs
|
|
fremoteName string
|
|
cleanRemote func()
|
|
skip bool
|
|
}
|
|
|
|
// run holds the master Run data
|
|
var run *Run
|
|
|
|
// newRun initialise the remote mount for testing and returns a run
|
|
// object.
|
|
//
|
|
// r.fremote is an empty remote Fs
|
|
//
|
|
// Finalise() will tidy them away when done.
|
|
func newRun(useVFS bool) *Run {
|
|
r := &Run{
|
|
useVFS: useVFS,
|
|
}
|
|
fstest.Initialise()
|
|
|
|
var err error
|
|
r.fremote, r.fremoteName, r.cleanRemote, err = fstest.RandomRemote()
|
|
if err != nil {
|
|
log.Fatalf("Failed to open remote %q: %v", *fstest.RemoteName, err)
|
|
}
|
|
|
|
err = r.fremote.Mkdir(context.Background(), "")
|
|
if err != nil {
|
|
log.Fatalf("Failed to open mkdir %q: %v", *fstest.RemoteName, err)
|
|
}
|
|
|
|
if !r.useVFS {
|
|
r.mountPath = findMountPath()
|
|
}
|
|
// Mount it up
|
|
r.mount()
|
|
|
|
return r
|
|
}
|
|
|
|
func findMountPath() string {
|
|
if runtime.GOOS != "windows" {
|
|
mountPath, err := ioutil.TempDir("", "rclonefs-mount")
|
|
if err != nil {
|
|
log.Fatalf("Failed to create mount dir: %v", err)
|
|
}
|
|
return mountPath
|
|
}
|
|
|
|
// Find a free drive letter
|
|
letter := file.FindUnusedDriveLetter()
|
|
drive := ""
|
|
if letter == 0 {
|
|
log.Fatalf("Couldn't find free drive letter for test")
|
|
} else {
|
|
drive = string(letter) + ":"
|
|
}
|
|
return drive
|
|
}
|
|
|
|
func (r *Run) mount() {
|
|
log.Printf("mount %q %q", r.fremote, r.mountPath)
|
|
var err error
|
|
r.mnt = mountlib.NewMountPoint(mountFn, r.mountPath, r.fremote, &mountlib.Opt, &vfsflags.Opt)
|
|
|
|
_, err = r.mnt.Mount()
|
|
if err != nil {
|
|
log.Printf("mount FAILED: %v", err)
|
|
r.skip = true
|
|
} else {
|
|
log.Printf("mount OK")
|
|
}
|
|
r.vfs = r.mnt.VFS
|
|
if r.useVFS {
|
|
r.os = vfsOs{r.vfs}
|
|
} else {
|
|
r.os = realOs{}
|
|
}
|
|
|
|
}
|
|
|
|
func (r *Run) umount() {
|
|
if r.skip {
|
|
log.Printf("FUSE not found so skipping umount")
|
|
return
|
|
}
|
|
/*
|
|
log.Printf("Calling fusermount -u %q", r.mountPath)
|
|
err := exec.Command("fusermount", "-u", r.mountPath).Run()
|
|
if err != nil {
|
|
log.Printf("fusermount failed: %v", err)
|
|
}
|
|
*/
|
|
log.Printf("Unmounting %q", r.mountPath)
|
|
err := r.mnt.Unmount()
|
|
if err != nil {
|
|
log.Printf("signal to umount failed - retrying: %v", err)
|
|
time.Sleep(3 * time.Second)
|
|
err = r.mnt.Unmount()
|
|
}
|
|
if err != nil {
|
|
log.Fatalf("signal to umount failed: %v", err)
|
|
}
|
|
log.Printf("Waiting for umount")
|
|
err = <-r.mnt.ErrChan
|
|
if err != nil {
|
|
log.Fatalf("umount failed: %v", err)
|
|
}
|
|
|
|
// Cleanup the VFS cache - umount has called Shutdown
|
|
err = r.vfs.CleanUp()
|
|
if err != nil {
|
|
log.Printf("Failed to cleanup the VFS cache: %v", err)
|
|
}
|
|
}
|
|
|
|
// cacheMode flushes the VFS and changes the CacheMode and the writeBack time
|
|
func (r *Run) cacheMode(cacheMode vfscommon.CacheMode, writeBack time.Duration) {
|
|
if r.skip {
|
|
log.Printf("FUSE not found so skipping cacheMode")
|
|
return
|
|
}
|
|
// Wait for writers to finish
|
|
r.vfs.WaitForWriters(waitForWritersDelay)
|
|
// Empty and remake the remote
|
|
r.cleanRemote()
|
|
err := r.fremote.Mkdir(context.Background(), "")
|
|
if err != nil {
|
|
log.Fatalf("Failed to open mkdir %q: %v", *fstest.RemoteName, err)
|
|
}
|
|
// Empty the cache
|
|
err = r.vfs.CleanUp()
|
|
if err != nil {
|
|
log.Printf("Failed to cleanup the VFS cache: %v", err)
|
|
}
|
|
// Reset the cache mode
|
|
r.vfs.SetCacheMode(cacheMode)
|
|
r.vfs.Opt.WriteBack = writeBack
|
|
// Flush the directory cache
|
|
r.vfs.FlushDirCache()
|
|
|
|
}
|
|
|
|
func (r *Run) skipIfNoFUSE(t *testing.T) {
|
|
if r.skip {
|
|
t.Skip("FUSE not found so skipping test")
|
|
}
|
|
}
|
|
|
|
func (r *Run) skipIfVFS(t *testing.T) {
|
|
if r.useVFS {
|
|
t.Skip("Not running under VFS")
|
|
}
|
|
}
|
|
|
|
// Finalise cleans the remote and unmounts
|
|
func (r *Run) Finalise() {
|
|
r.umount()
|
|
r.cleanRemote()
|
|
if r.useVFS {
|
|
// FIXME
|
|
} else {
|
|
err := os.RemoveAll(r.mountPath)
|
|
if err != nil {
|
|
log.Printf("Failed to clean mountPath %q: %v", r.mountPath, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// path returns an OS local path for filepath
|
|
func (r *Run) path(filePath string) string {
|
|
if r.useVFS {
|
|
return filePath
|
|
}
|
|
// return windows drive letter root as E:\
|
|
if filePath == "" && runtime.GOOS == "windows" {
|
|
return run.mountPath + `\`
|
|
}
|
|
return filepath.Join(run.mountPath, filepath.FromSlash(filePath))
|
|
}
|
|
|
|
type dirMap map[string]struct{}
|
|
|
|
// Create a dirMap from a string
|
|
func newDirMap(dirString string) (dm dirMap) {
|
|
dm = make(dirMap)
|
|
for _, entry := range strings.Split(dirString, "|") {
|
|
if entry != "" {
|
|
dm[entry] = struct{}{}
|
|
}
|
|
}
|
|
return dm
|
|
}
|
|
|
|
// Returns a dirmap with only the files in
|
|
func (dm dirMap) filesOnly() dirMap {
|
|
newDm := make(dirMap)
|
|
for name := range dm {
|
|
if !strings.HasSuffix(name, "/") {
|
|
newDm[name] = struct{}{}
|
|
}
|
|
}
|
|
return newDm
|
|
}
|
|
|
|
// reads the local tree into dir
|
|
func (r *Run) readLocal(t *testing.T, dir dirMap, filePath string) {
|
|
realPath := r.path(filePath)
|
|
files, err := r.os.ReadDir(realPath)
|
|
require.NoError(t, err)
|
|
for _, fi := range files {
|
|
name := path.Join(filePath, fi.Name())
|
|
if fi.IsDir() {
|
|
dir[name+"/"] = struct{}{}
|
|
r.readLocal(t, dir, name)
|
|
assert.Equal(t, run.vfs.Opt.DirPerms&os.ModePerm, fi.Mode().Perm())
|
|
} else {
|
|
dir[fmt.Sprintf("%s %d", name, fi.Size())] = struct{}{}
|
|
assert.Equal(t, run.vfs.Opt.FilePerms&os.ModePerm, fi.Mode().Perm())
|
|
}
|
|
}
|
|
}
|
|
|
|
// reads the remote tree into dir
|
|
func (r *Run) readRemote(t *testing.T, dir dirMap, filepath string) {
|
|
objs, dirs, err := walk.GetAll(context.Background(), r.fremote, filepath, true, 1)
|
|
if err == fs.ErrorDirNotFound {
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
for _, obj := range objs {
|
|
dir[fmt.Sprintf("%s %d", obj.Remote(), obj.Size())] = struct{}{}
|
|
}
|
|
for _, d := range dirs {
|
|
name := d.Remote()
|
|
dir[name+"/"] = struct{}{}
|
|
r.readRemote(t, dir, name)
|
|
}
|
|
}
|
|
|
|
// checkDir checks the local and remote against the string passed in
|
|
func (r *Run) checkDir(t *testing.T, dirString string) {
|
|
var retries = *fstest.ListRetries
|
|
sleep := time.Second / 5
|
|
var remoteOK, fuseOK bool
|
|
var dm, localDm, remoteDm dirMap
|
|
for i := 1; i <= retries; i++ {
|
|
dm = newDirMap(dirString)
|
|
localDm = make(dirMap)
|
|
r.readLocal(t, localDm, "")
|
|
remoteDm = make(dirMap)
|
|
r.readRemote(t, remoteDm, "")
|
|
// Ignore directories for remote compare
|
|
remoteOK = reflect.DeepEqual(dm.filesOnly(), remoteDm.filesOnly())
|
|
fuseOK = reflect.DeepEqual(dm, localDm)
|
|
if remoteOK && fuseOK {
|
|
return
|
|
}
|
|
sleep *= 2
|
|
t.Logf("Sleeping for %v for list eventual consistency: %d/%d", sleep, i, retries)
|
|
time.Sleep(sleep)
|
|
}
|
|
assert.Equal(t, dm.filesOnly(), remoteDm.filesOnly(), "expected vs remote")
|
|
assert.Equal(t, dm, localDm, "expected vs fuse mount")
|
|
}
|
|
|
|
// wait for any files being written to be released by fuse
|
|
func (r *Run) waitForWriters() {
|
|
run.vfs.WaitForWriters(waitForWritersDelay)
|
|
}
|
|
|
|
// writeFile writes data to a file named by filename.
|
|
// If the file does not exist, WriteFile creates it with permissions perm;
|
|
// otherwise writeFile truncates it before writing.
|
|
// If there is an error writing then writeFile
|
|
// deletes it an existing file and tries again.
|
|
func writeFile(filename string, data []byte, perm os.FileMode) error {
|
|
f, err := run.os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
|
|
if err != nil {
|
|
err = run.os.Remove(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f, err = run.os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, perm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
n, err := f.Write(data)
|
|
if err == nil && n < len(data) {
|
|
err = io.ErrShortWrite
|
|
}
|
|
if err1 := f.Close(); err == nil {
|
|
err = err1
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (r *Run) createFile(t *testing.T, filepath string, contents string) {
|
|
filepath = r.path(filepath)
|
|
err := writeFile(filepath, []byte(contents), 0600)
|
|
require.NoError(t, err)
|
|
r.waitForWriters()
|
|
}
|
|
|
|
func (r *Run) readFile(t *testing.T, filepath string) string {
|
|
filepath = r.path(filepath)
|
|
result, err := run.os.ReadFile(filepath)
|
|
require.NoError(t, err)
|
|
return string(result)
|
|
}
|
|
|
|
func (r *Run) mkdir(t *testing.T, filepath string) {
|
|
filepath = r.path(filepath)
|
|
err := run.os.Mkdir(filepath, 0700)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func (r *Run) rm(t *testing.T, filepath string) {
|
|
filepath = r.path(filepath)
|
|
err := run.os.Remove(filepath)
|
|
require.NoError(t, err)
|
|
|
|
// Wait for file to disappear from listing
|
|
for i := 0; i < 100; i++ {
|
|
_, err := run.os.Stat(filepath)
|
|
if os.IsNotExist(err) {
|
|
return
|
|
}
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
assert.Fail(t, "failed to delete file", filepath)
|
|
}
|
|
|
|
func (r *Run) rmdir(t *testing.T, filepath string) {
|
|
filepath = r.path(filepath)
|
|
err := run.os.Remove(filepath)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// TestMount checks that the Fs is mounted by seeing if the mountpoint
|
|
// is in the mount output
|
|
func TestMount(t *testing.T) {
|
|
run.skipIfVFS(t)
|
|
run.skipIfNoFUSE(t)
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("not running on windows")
|
|
}
|
|
|
|
out, err := exec.Command("mount").Output()
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(out), run.mountPath)
|
|
}
|
|
|
|
// TestRoot checks root directory is present and correct
|
|
func TestRoot(t *testing.T) {
|
|
run.skipIfVFS(t)
|
|
run.skipIfNoFUSE(t)
|
|
|
|
fi, err := os.Lstat(run.mountPath)
|
|
require.NoError(t, err)
|
|
assert.True(t, fi.IsDir())
|
|
assert.Equal(t, run.vfs.Opt.DirPerms&os.ModePerm, fi.Mode().Perm())
|
|
}
|