Revert "lib/model, gui: Allow creating and editing ignores of paused folders (fixes #3608)"

This reverts commit 25b314f5f1.

lib/model/folder.go

@@ -10,11 +10,9 @@ import "time"
 
 type folder struct {
 	stateTracker
-
-	scan                 folderScanner
-	model                *Model
-	stop                 chan struct{}
-	initialScanCompleted chan struct{}
+	scan  folderScanner
+	model *Model
+	stop  chan struct{}
 }
 
 func (f *folder) IndexUpdated() {
@@ -25,7 +23,6 @@ func (f *folder) DelayScan(next time.Duration) {
 }
 
 func (f *folder) Scan(subdirs []string) error {
-	<-f.initialScanCompleted
 	return f.scan.Scan(subdirs)
 }
 func (f *folder) Stop() {

lib/model/model.go

@@ -7,6 +7,7 @@
 package model
 
 import (
+	"bufio"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -1251,51 +1252,66 @@ func (m *Model) ConnectedTo(deviceID protocol.DeviceID) bool {
 }
 
 func (m *Model) GetIgnores(folder string) ([]string, []string, error) {
+	var lines []string
+
 	m.fmut.RLock()
 	cfg, ok := m.folderCfgs[folder]
 	m.fmut.RUnlock()
-	if ok {
-		if !cfg.HasMarker() {
-			return nil, nil, fmt.Errorf("Folder %s stopped", folder)
-		}
-
-		m.fmut.RLock()
-		ignores := m.folderIgnores[folder]
-		m.fmut.RUnlock()
-
-		return ignores.Lines(), ignores.Patterns(), nil
+	if !ok {
+		return lines, nil, fmt.Errorf("Folder %s does not exist", folder)
 	}
 
-	if cfg, ok := m.cfg.Folders()[folder]; ok {
-		matcher := ignore.New(false)
-		path := filepath.Join(cfg.Path(), ".stignore")
-		if err := matcher.Load(path); err != nil {
-			return nil, nil, err
-		}
-		return matcher.Lines(), matcher.Patterns(), nil
+	if !cfg.HasMarker() {
+		return lines, nil, fmt.Errorf("Folder %s stopped", folder)
 	}
 
-	return nil, nil, fmt.Errorf("Folder %s does not exist", folder)
+	fd, err := os.Open(filepath.Join(cfg.Path(), ".stignore"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return lines, nil, nil
+		}
+		l.Warnln("Loading .stignore:", err)
+		return lines, nil, err
+	}
+	defer fd.Close()
+
+	scanner := bufio.NewScanner(fd)
+	for scanner.Scan() {
+		lines = append(lines, strings.TrimSpace(scanner.Text()))
+	}
+
+	m.fmut.RLock()
+	patterns := m.folderIgnores[folder].Patterns()
+	m.fmut.RUnlock()
+
+	return lines, patterns, nil
 }
 
 func (m *Model) SetIgnores(folder string, content []string) error {
-	cfg, ok := m.cfg.Folders()[folder]
+	cfg, ok := m.folderCfgs[folder]
 	if !ok {
 		return fmt.Errorf("Folder %s does not exist", folder)
 	}
 
-	if err := ignore.WriteIgnores(filepath.Join(cfg.Path(), ".stignore"), content); err != nil {
+	path := filepath.Join(cfg.Path(), ".stignore")
+
+	fd, err := osutil.CreateAtomic(path)
+	if err != nil {
 		l.Warnln("Saving .stignore:", err)
 		return err
 	}
 
-	m.fmut.RLock()
-	runner, ok := m.folderRunners[folder]
-	m.fmut.RUnlock()
-	if ok {
-		return runner.Scan(nil)
+	for _, line := range content {
+		fmt.Fprintln(fd, line)
 	}
-	return nil
+
+	if err := fd.Close(); err != nil {
+		l.Warnln("Saving .stignore:", err)
+		return err
+	}
+	osutil.HideFile(path)
+
+	return m.ScanFolder(folder)
 }
 
 // OnHello is called when an device connects to us.
@@ -2379,13 +2395,9 @@ func (m *Model) CommitConfiguration(from, to config.Configuration) bool {
 	for folderID, cfg := range toFolders {
 		if _, ok := fromFolders[folderID]; !ok {
 			// A folder was added.
-			if cfg.Paused {
-				l.Infoln(m, "Paused folder", cfg.Description())
-			} else {
-				l.Infoln(m, "Adding folder", cfg.Description())
-				m.AddFolder(cfg)
-				m.StartFolder(folderID)
-			}
+			l.Debugln(m, "adding folder", folderID)
+			m.AddFolder(cfg)
+			m.StartFolder(folderID)
 		}
 	}
 

lib/model/model_test.go

@@ -927,7 +927,7 @@ func TestIntroducer(t *testing.T) {
 	}
 }
 
-func changeIgnores(t *testing.T, m *Model, expected []string) {
+func TestIgnores(t *testing.T) {
 	arrEqual := func(a, b []string) bool {
 		if len(a) != len(b) {
 			return false
@@ -941,6 +941,22 @@ func changeIgnores(t *testing.T, m *Model, expected []string) {
 		return true
 	}
 
+	// Assure a clean start state
+	ioutil.WriteFile("testdata/.stfolder", nil, 0644)
+	ioutil.WriteFile("testdata/.stignore", []byte(".*\nquux\n"), 0644)
+
+	db := db.OpenMemory()
+	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", db, nil)
+	m.AddFolder(defaultFolderConfig)
+	m.StartFolder("default")
+	m.ServeBackground()
+	defer m.Stop()
+
+	expected := []string{
+		".*",
+		"quux",
+	}
+
 	ignores, _, err := m.GetIgnores("default")
 	if err != nil {
 		t.Error(err)
@@ -989,34 +1005,8 @@ func changeIgnores(t *testing.T, m *Model, expected []string) {
 	if !arrEqual(ignores, expected) {
 		t.Errorf("Incorrect ignores: %v != %v", ignores, expected)
 	}
-}
 
-func TestIgnores(t *testing.T) {
-	// Assure a clean start state
-	ioutil.WriteFile("testdata/.stfolder", nil, 0644)
-	ioutil.WriteFile("testdata/.stignore", []byte(".*\nquux\n"), 0644)
-
-	db := db.OpenMemory()
-	m := NewModel(defaultConfig, protocol.LocalDeviceID, "device", "syncthing", "dev", db, nil)
-	m.ServeBackground()
-	defer m.Stop()
-
-	// m.cfg.SetFolder is not usable as it is non-blocking, and there is no
-	// way to know when the folder is actually added.
-	m.AddFolder(defaultFolderConfig)
-	m.StartFolder("default")
-
-	// Make sure the initial scan has finished (ScanFolders is blocking)
-	m.ScanFolders()
-
-	expected := []string{
-		".*",
-		"quux",
-	}
-
-	changeIgnores(t, m, expected)
-
-	_, _, err := m.GetIgnores("doesnotexist")
+	_, _, err = m.GetIgnores("doesnotexist")
 	if err == nil {
 		t.Error("No error")
 	}
@@ -1032,16 +1022,6 @@ func TestIgnores(t *testing.T) {
 	if err == nil {
 		t.Error("No error")
 	}
-
-	// Repeat tests with paused folder
-	pausedDefaultFolderConfig := defaultFolderConfig
-	pausedDefaultFolderConfig.Paused = true
-
-	m.RestartFolder(pausedDefaultFolderConfig)
-	// Here folder initialization is not an issue as a paused folder isn't
-	// added to the model and thus there is no initial scan happening.
-
-	changeIgnores(t, m, expected)
 }
 
 func TestROScanRecovery(t *testing.T) {
@@ -1789,8 +1769,13 @@ func TestIssue3028(t *testing.T) {
 	m.StartFolder("default")
 	m.ServeBackground()
 
-	// Make sure the initial scan has finished (ScanFolders is blocking)
-	m.ScanFolders()
+	// Ugly hack for testing: reach into the model for the SendReceiveFolder and wait
+	// for it to complete the initial scan. The risk is that it otherwise
+	// runs during our modifications and screws up the test.
+	m.fmut.RLock()
+	folder := m.folderRunners["default"].(*sendReceiveFolder)
+	m.fmut.RUnlock()
+	<-folder.initialScanCompleted
 
 	// Get a count of how many files are there now
 

lib/model/rofolder.go

@@ -26,11 +26,10 @@ type sendOnlyFolder struct {
 func newSendOnlyFolder(model *Model, cfg config.FolderConfiguration, _ versioner.Versioner, _ *fs.MtimeFS) service {
 	return &sendOnlyFolder{
 		folder: folder{
-			stateTracker:         newStateTracker(cfg.ID),
-			scan:                 newFolderScanner(cfg),
-			stop:                 make(chan struct{}),
-			model:                model,
-			initialScanCompleted: make(chan struct{}),
+			stateTracker: newStateTracker(cfg.ID),
+			scan:         newFolderScanner(cfg),
+			stop:         make(chan struct{}),
+			model:        model,
 		},
 		FolderConfiguration: cfg,
 	}
@@ -44,6 +43,7 @@ func (f *sendOnlyFolder) Serve() {
 		f.scan.timer.Stop()
 	}()
 
+	initialScanCompleted := false
 	for {
 		select {
 		case <-f.stop:
@@ -68,11 +68,9 @@ func (f *sendOnlyFolder) Serve() {
 				continue
 			}
 
-			select {
-			case <-f.initialScanCompleted:
-			default:
+			if !initialScanCompleted {
 				l.Infoln("Completed initial scan (ro) of", f.Description())
-				close(f.initialScanCompleted)
+				initialScanCompleted = true
 			}
 
 			if f.scan.HasNoInterval() {

lib/model/rwfolder.go

@@ -96,16 +96,17 @@ type sendReceiveFolder struct {
 
 	errors    map[string]string // path -> error string
 	errorsMut sync.Mutex
+
+	initialScanCompleted chan (struct{}) // exposed for testing
 }
 
 func newSendReceiveFolder(model *Model, cfg config.FolderConfiguration, ver versioner.Versioner, mtimeFS *fs.MtimeFS) service {
 	f := &sendReceiveFolder{
 		folder: folder{
-			stateTracker:         newStateTracker(cfg.ID),
-			scan:                 newFolderScanner(cfg),
-			stop:                 make(chan struct{}),
-			model:                model,
-			initialScanCompleted: make(chan struct{}),
+			stateTracker: newStateTracker(cfg.ID),
+			scan:         newFolderScanner(cfg),
+			stop:         make(chan struct{}),
+			model:        model,
 		},
 		FolderConfiguration: cfg,
 
@@ -118,6 +119,8 @@ func newSendReceiveFolder(model *Model, cfg config.FolderConfiguration, ver vers
 		remoteIndex: make(chan struct{}, 1), // This needs to be 1-buffered so that we queue a notification if we're busy doing a pull when it comes.
 
 		errorsMut: sync.NewMutex(),
+
+		initialScanCompleted: make(chan struct{}),
 	}
 
 	f.configureCopiersAndPullers()
@@ -1060,7 +1063,7 @@ func (f *sendReceiveFolder) handleFile(file protocol.FileInfo, copyChan chan<- c
 				// sweep is complete. As we do retries, we'll queue the scan
 				// for this file up to ten times, but the last nine of those
 				// scans will be cheap...
-				go f.Scan([]string{file.Name})
+				go f.scan.Scan([]string{file.Name})
 				return
 			}
 		}

lib/model/rwfolder_test.go

@@ -77,12 +77,11 @@ func setUpModel(file protocol.FileInfo) *Model {
 	return model
 }
 
-func setUpSendReceiveFolder(model *Model) *sendReceiveFolder {
-	f := &sendReceiveFolder{
+func setUpSendReceiveFolder(model *Model) sendReceiveFolder {
+	return sendReceiveFolder{
 		folder: folder{
-			stateTracker:         newStateTracker("default"),
-			model:                model,
-			initialScanCompleted: make(chan struct{}),
+			stateTracker: newStateTracker("default"),
+			model:        model,
 		},
 
 		mtimeFS:   fs.NewMtimeFS(fs.DefaultFilesystem, db.NewNamespacedKV(model.db, "mtime")),
@@ -91,11 +90,6 @@ func setUpSendReceiveFolder(model *Model) *sendReceiveFolder {
 		errors:    make(map[string]string),
 		errorsMut: sync.NewMutex(),
 	}
-
-	// Folders are never actually started, so no initial scan will be done
-	close(f.initialScanCompleted)
-
-	return f
 }
 
 // Layout of the files: (indexes from the above array)