all: Add package runtimeos for runtime.GOOS comparisons I grew tired of hand written string comparisons. This adds generated constants for the GOOS values, and predefined Is$OS constants that can be iffed on. In a couple of places I rewrote trivial switch:es to if:s, and added Illumos where we checked for Solaris (because they are effectively the same, and if we're going to target one of them that would be Illumos...).
637 lines
15 KiB
Go
637 lines
15 KiB
Go
// Copyright (C) 2016 The Syncthing Authors.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
//go:build (!solaris && !darwin) || (solaris && cgo) || (darwin && cgo)
|
|
// +build !solaris,!darwin solaris,cgo darwin,cgo
|
|
|
|
package fs
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/syncthing/notify"
|
|
"github.com/syncthing/syncthing/lib/build"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
if err := os.RemoveAll(testDir); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
dir, err := filepath.Abs(".")
|
|
if err != nil {
|
|
panic("Cannot get absolute path to working dir")
|
|
}
|
|
|
|
dir, err = evalSymlinks(dir)
|
|
if err != nil {
|
|
panic("Cannot get real path to working dir")
|
|
}
|
|
|
|
testDirAbs = filepath.Join(dir, testDir)
|
|
if build.IsWindows {
|
|
testDirAbs = longFilenameSupport(testDirAbs)
|
|
}
|
|
|
|
testFs = NewFilesystem(FilesystemTypeBasic, testDirAbs)
|
|
|
|
backendBuffer = 10
|
|
|
|
exitCode := m.Run()
|
|
|
|
backendBuffer = 500
|
|
os.RemoveAll(testDir)
|
|
|
|
os.Exit(exitCode)
|
|
}
|
|
|
|
const (
|
|
testDir = "testdata"
|
|
failsOnOpenBSD = "Fails on OpenBSD. See https://github.com/rjeczalik/notify/issues/172"
|
|
)
|
|
|
|
var (
|
|
testDirAbs string
|
|
testFs Filesystem
|
|
)
|
|
|
|
func TestWatchIgnore(t *testing.T) {
|
|
if build.IsOpenBSD {
|
|
t.Skip(failsOnOpenBSD)
|
|
}
|
|
name := "ignore"
|
|
|
|
file := "file"
|
|
ignored := "ignored"
|
|
|
|
testCase := func() {
|
|
createTestFile(name, file)
|
|
createTestFile(name, ignored)
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{file, NonRemove},
|
|
}
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{ignore: filepath.Join(name, ignored), skipIgnoredDirs: true}, false)
|
|
}
|
|
|
|
func TestWatchInclude(t *testing.T) {
|
|
if build.IsOpenBSD {
|
|
t.Skip(failsOnOpenBSD)
|
|
}
|
|
name := "include"
|
|
|
|
file := "file"
|
|
ignored := "ignored"
|
|
testFs.MkdirAll(filepath.Join(name, ignored), 0777)
|
|
included := filepath.Join(ignored, "included")
|
|
|
|
testCase := func() {
|
|
createTestFile(name, file)
|
|
createTestFile(name, included)
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{file, NonRemove},
|
|
{included, NonRemove},
|
|
}
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{ignore: filepath.Join(name, ignored), include: filepath.Join(name, included)}, false)
|
|
}
|
|
|
|
func TestWatchRename(t *testing.T) {
|
|
if build.IsOpenBSD {
|
|
t.Skip(failsOnOpenBSD)
|
|
}
|
|
name := "rename"
|
|
|
|
old := createTestFile(name, "oldfile")
|
|
new := "newfile"
|
|
|
|
testCase := func() {
|
|
renameTestFile(name, old, new)
|
|
}
|
|
|
|
destEvent := Event{new, Remove}
|
|
// Only on these platforms the removed file can be differentiated from
|
|
// the created file during renaming
|
|
if build.IsWindows || build.IsLinux || build.IsSolaris || build.IsIllumos || build.IsFreeBSD {
|
|
destEvent = Event{new, NonRemove}
|
|
}
|
|
expectedEvents := []Event{
|
|
{old, Remove},
|
|
destEvent,
|
|
}
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
// set the "allow others" flag because we might get the create of
|
|
// "oldfile" initially
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, false)
|
|
}
|
|
|
|
// TestWatchWinRoot checks that a watch at a drive letter does not panic due to
|
|
// out of root event on every event.
|
|
// https://github.com/syncthing/syncthing/issues/5695
|
|
func TestWatchWinRoot(t *testing.T) {
|
|
if !build.IsWindows {
|
|
t.Skip("Windows specific test")
|
|
}
|
|
|
|
outChan := make(chan Event)
|
|
backendChan := make(chan notify.EventInfo, backendBuffer)
|
|
errChan := make(chan error)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
// testFs is Filesystem, but we need BasicFilesystem here
|
|
root := `D:\`
|
|
fs := newBasicFilesystem(root)
|
|
watch, roots, err := fs.watchPaths(".")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
done := make(chan struct{})
|
|
defer func() {
|
|
cancel()
|
|
<-done
|
|
}()
|
|
go func() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Error(r)
|
|
}
|
|
cancel()
|
|
}()
|
|
fs.watchLoop(ctx, ".", roots, backendChan, outChan, errChan, fakeMatcher{})
|
|
close(done)
|
|
}()
|
|
|
|
// filepath.Dir as watch has a /... suffix
|
|
name := "foo"
|
|
backendChan <- fakeEventInfo(filepath.Join(filepath.Dir(watch), name))
|
|
|
|
select {
|
|
case <-time.After(10 * time.Second):
|
|
cancel()
|
|
t.Errorf("Timed out before receiving event")
|
|
case ev := <-outChan:
|
|
if ev.Name != name {
|
|
t.Errorf("Unexpected event %v, expected %v", ev.Name, name)
|
|
}
|
|
case err := <-errChan:
|
|
t.Error("Received fatal watch error:", err)
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
|
|
// TestWatchOutside checks that no changes from outside the folder make it in
|
|
func TestWatchOutside(t *testing.T) {
|
|
expectErrorForPath(t, filepath.Join(filepath.Dir(testDirAbs), "outside"))
|
|
|
|
rootWithoutSlash := strings.TrimRight(filepath.ToSlash(testDirAbs), "/")
|
|
expectErrorForPath(t, rootWithoutSlash+"outside")
|
|
expectErrorForPath(t, rootWithoutSlash+"outside/thing")
|
|
}
|
|
|
|
func expectErrorForPath(t *testing.T, path string) {
|
|
outChan := make(chan Event)
|
|
backendChan := make(chan notify.EventInfo, backendBuffer)
|
|
errChan := make(chan error)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
// testFs is Filesystem, but we need BasicFilesystem here
|
|
fs := newBasicFilesystem(testDirAbs)
|
|
|
|
done := make(chan struct{})
|
|
go func() {
|
|
fs.watchLoop(ctx, ".", []string{testDirAbs}, backendChan, outChan, errChan, fakeMatcher{})
|
|
close(done)
|
|
}()
|
|
defer func() {
|
|
cancel()
|
|
<-done
|
|
}()
|
|
|
|
backendChan <- fakeEventInfo(path)
|
|
|
|
select {
|
|
case <-time.After(10 * time.Second):
|
|
t.Errorf("Timed out before receiving error")
|
|
case e := <-outChan:
|
|
t.Errorf("Unexpected passed through event %v", e)
|
|
case <-errChan:
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
|
|
func TestWatchSubpath(t *testing.T) {
|
|
outChan := make(chan Event)
|
|
backendChan := make(chan notify.EventInfo, backendBuffer)
|
|
errChan := make(chan error)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
// testFs is Filesystem, but we need BasicFilesystem here
|
|
fs := newBasicFilesystem(testDirAbs)
|
|
|
|
abs, _ := fs.rooted("sub")
|
|
done := make(chan struct{})
|
|
go func() {
|
|
fs.watchLoop(ctx, "sub", []string{testDirAbs}, backendChan, outChan, errChan, fakeMatcher{})
|
|
close(done)
|
|
}()
|
|
defer func() {
|
|
cancel()
|
|
<-done
|
|
}()
|
|
|
|
backendChan <- fakeEventInfo(filepath.Join(abs, "file"))
|
|
|
|
timeout := time.NewTimer(2 * time.Second)
|
|
select {
|
|
case <-timeout.C:
|
|
t.Errorf("Timed out before receiving an event")
|
|
cancel()
|
|
case ev := <-outChan:
|
|
if ev.Name != filepath.Join("sub", "file") {
|
|
t.Errorf("While watching a subfolder, received an event with unexpected path %v", ev.Name)
|
|
}
|
|
case err := <-errChan:
|
|
t.Error("Received fatal watch error:", err)
|
|
}
|
|
|
|
cancel()
|
|
}
|
|
|
|
// TestWatchOverflow checks that an event at the root is sent when maxFiles is reached
|
|
func TestWatchOverflow(t *testing.T) {
|
|
if build.IsOpenBSD {
|
|
t.Skip(failsOnOpenBSD)
|
|
}
|
|
name := "overflow"
|
|
|
|
expectedEvents := []Event{
|
|
{".", NonRemove},
|
|
}
|
|
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
testCase := func() {
|
|
for i := 0; i < 5*backendBuffer; i++ {
|
|
file := "file" + strconv.Itoa(i)
|
|
createTestFile(name, file)
|
|
allowedEvents = append(allowedEvents, Event{file, NonRemove})
|
|
}
|
|
}
|
|
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, false)
|
|
}
|
|
|
|
func TestWatchErrorLinuxInterpretation(t *testing.T) {
|
|
if !build.IsLinux {
|
|
t.Skip("testing of linux specific error codes")
|
|
}
|
|
|
|
var errTooManyFiles = &os.PathError{
|
|
Op: "error while traversing",
|
|
Path: "foo",
|
|
Err: syscall.Errno(24),
|
|
}
|
|
var errNoSpace = &os.PathError{
|
|
Op: "error while traversing",
|
|
Path: "bar",
|
|
Err: syscall.Errno(28),
|
|
}
|
|
|
|
if !reachedMaxUserWatches(errTooManyFiles) {
|
|
t.Error("Underlying error syscall.Errno(24) should be recognised to be about inotify limits.")
|
|
}
|
|
if !reachedMaxUserWatches(errNoSpace) {
|
|
t.Error("Underlying error syscall.Errno(28) should be recognised to be about inotify limits.")
|
|
}
|
|
err := errors.New("Another error")
|
|
if reachedMaxUserWatches(err) {
|
|
t.Errorf("This error does not concern inotify limits: %#v", err)
|
|
}
|
|
}
|
|
|
|
func TestWatchSymlinkedRoot(t *testing.T) {
|
|
if build.IsWindows {
|
|
t.Skip("Involves symlinks")
|
|
}
|
|
|
|
name := "symlinkedRoot"
|
|
if err := testFs.MkdirAll(name, 0755); err != nil {
|
|
panic(fmt.Sprintf("Failed to create directory %s: %s", name, err))
|
|
}
|
|
defer testFs.RemoveAll(name)
|
|
|
|
root := filepath.Join(name, "root")
|
|
if err := testFs.MkdirAll(root, 0777); err != nil {
|
|
panic(err)
|
|
}
|
|
link := filepath.Join(name, "link")
|
|
|
|
if err := testFs.CreateSymlink(filepath.Join(testFs.URI(), root), link); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
linkedFs := NewFilesystem(FilesystemTypeBasic, filepath.Join(testFs.URI(), link))
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
if _, _, err := linkedFs.Watch(".", fakeMatcher{}, ctx, false); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if err := linkedFs.MkdirAll("foo", 0777); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Give the panic some time to happen
|
|
sleepMs(100)
|
|
}
|
|
|
|
func TestUnrootedChecked(t *testing.T) {
|
|
fs := newBasicFilesystem(testDirAbs)
|
|
if unrooted, err := fs.unrootedChecked("/random/other/path", []string{testDirAbs}); err == nil {
|
|
t.Error("unrootedChecked did not return an error on outside path, but returned", unrooted)
|
|
}
|
|
}
|
|
|
|
func TestWatchIssue4877(t *testing.T) {
|
|
if !build.IsWindows {
|
|
t.Skip("Windows specific test")
|
|
}
|
|
|
|
name := "Issue4877"
|
|
|
|
file := "file"
|
|
|
|
testCase := func() {
|
|
createTestFile(name, file)
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{file, NonRemove},
|
|
}
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
volName := filepath.VolumeName(testDirAbs)
|
|
if volName == "" {
|
|
t.Fatalf("Failed to get volume name for path %v", testDirAbs)
|
|
}
|
|
origTestFs := testFs
|
|
testFs = NewFilesystem(FilesystemTypeBasic, strings.ToLower(volName)+strings.ToUpper(testDirAbs[len(volName):]))
|
|
defer func() {
|
|
testFs = origTestFs
|
|
}()
|
|
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, false)
|
|
}
|
|
|
|
func TestWatchModTime(t *testing.T) {
|
|
name := "modtime"
|
|
|
|
file := createTestFile(name, "foo")
|
|
path := filepath.Join(name, file)
|
|
now := time.Now()
|
|
before := now.Add(-10 * time.Second)
|
|
if err := testFs.Chtimes(path, before, before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
testCase := func() {
|
|
if err := testFs.Chtimes(path, now, now); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{file, NonRemove},
|
|
}
|
|
|
|
var allowedEvents []Event
|
|
// Apparently an event for the parent is also sent on mac
|
|
if build.IsDarwin {
|
|
allowedEvents = []Event{
|
|
{name, NonRemove},
|
|
}
|
|
}
|
|
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, false)
|
|
}
|
|
|
|
func TestModifyFile(t *testing.T) {
|
|
name := "modify"
|
|
|
|
old := createTestFile(name, "file")
|
|
modifyTestFile(name, old, "syncthing")
|
|
|
|
testCase := func() {
|
|
modifyTestFile(name, old, "modified")
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{old, NonRemove},
|
|
}
|
|
allowedEvents := []Event{
|
|
{name, NonRemove},
|
|
}
|
|
|
|
sleepMs(1000)
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, false)
|
|
}
|
|
|
|
func TestTruncateFileOnly(t *testing.T) {
|
|
name := "truncate"
|
|
|
|
file := createTestFile(name, "file")
|
|
modifyTestFile(name, file, "syncthing")
|
|
|
|
// modified the content to empty use os.WriteFile will first truncate the file
|
|
// (/os/file.go:696) then write nothing. This logic is also used in many editors,
|
|
// such as when emptying a file in VSCode or JetBrain
|
|
//
|
|
// darwin will only modified the inode's metadata, such us mtime, file size, etc.
|
|
// but would not modified the file directly, so FSEvent 'FSEventsModified' will not
|
|
// be received
|
|
//
|
|
// we should watch the FSEvent 'FSEventsInodeMetaMod' to watch the Inode metadata,
|
|
// and that should be considered as an NonRemove Event
|
|
//
|
|
// notify also considered FSEventsInodeMetaMod as Write Event
|
|
// /watcher_fsevents.go:89
|
|
testCase := func() {
|
|
modifyTestFile(name, file, "")
|
|
}
|
|
|
|
expectedEvents := []Event{
|
|
{file, NonRemove},
|
|
}
|
|
allowedEvents := []Event{
|
|
{file, NonRemove},
|
|
}
|
|
|
|
sleepMs(1000)
|
|
testScenario(t, name, testCase, expectedEvents, allowedEvents, fakeMatcher{}, true)
|
|
}
|
|
|
|
// path relative to folder root, also creates parent dirs if necessary
|
|
func createTestFile(name string, file string) string {
|
|
joined := filepath.Join(name, file)
|
|
if err := testFs.MkdirAll(filepath.Dir(joined), 0755); err != nil {
|
|
panic(fmt.Sprintf("Failed to create parent directory for %s: %s", joined, err))
|
|
}
|
|
handle, err := testFs.Create(joined)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("Failed to create test file %s: %s", joined, err))
|
|
}
|
|
handle.Close()
|
|
return file
|
|
}
|
|
|
|
func renameTestFile(name string, old string, new string) {
|
|
old = filepath.Join(name, old)
|
|
new = filepath.Join(name, new)
|
|
if err := testFs.Rename(old, new); err != nil {
|
|
panic(fmt.Sprintf("Failed to rename %s to %s: %s", old, new, err))
|
|
}
|
|
}
|
|
|
|
func modifyTestFile(name string, file string, content string) {
|
|
joined := filepath.Join(testDirAbs, name, file)
|
|
|
|
err := os.WriteFile(joined, []byte(content), 0755)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("Failed to modify test file %s: %s", joined, err))
|
|
}
|
|
}
|
|
|
|
func sleepMs(ms int) {
|
|
time.Sleep(time.Duration(ms) * time.Millisecond)
|
|
}
|
|
|
|
func testScenario(t *testing.T, name string, testCase func(), expectedEvents, allowedEvents []Event, fm fakeMatcher, ignorePerms bool) {
|
|
if err := testFs.MkdirAll(name, 0755); err != nil {
|
|
panic(fmt.Sprintf("Failed to create directory %s: %s", name, err))
|
|
}
|
|
defer testFs.RemoveAll(name)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
eventChan, errChan, err := testFs.Watch(name, fm, ctx, ignorePerms)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
go testWatchOutput(t, name, eventChan, expectedEvents, allowedEvents, ctx, cancel)
|
|
|
|
testCase()
|
|
|
|
select {
|
|
case <-time.After(10 * time.Second):
|
|
t.Error("Timed out before receiving all expected events")
|
|
case err := <-errChan:
|
|
t.Error("Received fatal watch error:", err)
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
|
|
func testWatchOutput(t *testing.T, name string, in <-chan Event, expectedEvents, allowedEvents []Event, ctx context.Context, cancel context.CancelFunc) {
|
|
var expected = make(map[Event]struct{})
|
|
for _, ev := range expectedEvents {
|
|
ev.Name = filepath.Join(name, ev.Name)
|
|
expected[ev] = struct{}{}
|
|
}
|
|
|
|
var received Event
|
|
var last Event
|
|
for {
|
|
if len(expected) == 0 {
|
|
cancel()
|
|
return
|
|
}
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case received = <-in:
|
|
}
|
|
|
|
// apparently the backend sometimes sends repeat events
|
|
if last == received {
|
|
continue
|
|
}
|
|
|
|
if _, ok := expected[received]; !ok {
|
|
if len(allowedEvents) > 0 {
|
|
sleepMs(100) // To facilitate overflow
|
|
continue
|
|
}
|
|
t.Errorf("Received unexpected event %v expected one of %v", received, expected)
|
|
cancel()
|
|
return
|
|
}
|
|
delete(expected, received)
|
|
last = received
|
|
}
|
|
}
|
|
|
|
// Matches are done via direct comparison against both ignore and include
|
|
type fakeMatcher struct {
|
|
ignore string
|
|
include string
|
|
skipIgnoredDirs bool
|
|
}
|
|
|
|
func (fm fakeMatcher) ShouldIgnore(name string) bool {
|
|
return name != fm.include && name == fm.ignore
|
|
}
|
|
|
|
func (fm fakeMatcher) SkipIgnoredDirs() bool {
|
|
return fm.skipIgnoredDirs
|
|
}
|
|
|
|
type fakeEventInfo string
|
|
|
|
func (e fakeEventInfo) Path() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (fakeEventInfo) Event() notify.Event {
|
|
return notify.Write
|
|
}
|
|
|
|
func (fakeEventInfo) Sys() interface{} {
|
|
return nil
|
|
}
|