diff --git a/error.go b/error.go
index 47ef9f120ad9a02040e7cdd986ff0914f7faa070..c5cea17d9a5da5f5d3781ee620944287ffa52a50 100644
--- a/error.go
+++ b/error.go
@@ -29,9 +29,30 @@ func (e WatcherNotActiveError) Error() string {
return "Watcher is not active"
}
+// WatcherNotActiveError represents an error when trying to add a path that is already being watched.
+type WatcherNotRunningError struct{}
+
+func (e WatcherNotRunningError) Error() string {
+ return "Watcher is not active"
+}
+
+// WatcherAlreadyRunningError represents an error when trying to add a path that is already being watched.
+type WatcherAlreadyRunningError struct{}
+
+func (e WatcherAlreadyRunningError) Error() string {
+ return "Watcher is already running"
+}
+
// LighthouseNotActiveError represents an error when trying to add a path that is already being watched.
type LighthouseNotActiveError struct{}
func (e LighthouseNotActiveError) Error() string {
return "lighthouse is not active"
}
+
+// WatcherNotActiveError represents an error when trying to add a path that is already being watched.
+type WatcherAlreadyActiveError struct{}
+
+func (e WatcherAlreadyActiveError) Error() string {
+ return "Watcher is already active"
+}
diff --git a/lighthouse.go b/lighthouse.go
index 3befc5d4617d9cddcaff50e48cb305efbdb50c71..bbbe34660e330979b8ae44a6689622f5d08d566a 100644
--- a/lighthouse.go
+++ b/lighthouse.go
@@ -23,8 +23,10 @@ type lighthouse struct {
fsnotify *fsnotify.Watcher
mutex sync.Mutex
active bool
+ running bool
onError EventErrorCallback
debounce time.Duration
+ quit chan struct{}
}
// SetOnError Methode, um onError zu setzen
@@ -47,7 +49,11 @@ type Lighthouse interface {
IsActiveWatched(path string) bool
IsWatched(path string) bool
IsRunning() bool
- StartWatching()
+
+ IsActive() bool
+ StartWatching() error
+
+ StopWatching() error
SetOnError(callback EventErrorCallback)
SetDebounce(duration time.Duration)
@@ -56,6 +62,7 @@ type Lighthouse interface {
// NewLighthouse creates a new lighthouse instance.
func NewLighthouse() Lighthouse {
l := &lighthouse{}
+ l.debounce = 500 * time.Millisecond
l.checkAndInit()
return l
@@ -63,30 +70,49 @@ func NewLighthouse() Lighthouse {
func (l *lighthouse) checkAndInit() {
+ var err error
+
if l.active {
return
}
- l.debounce = 500 * time.Millisecond
-
if l.watchers == nil {
l.watchers = make(map[string]*Watch)
}
if l.fsnotify == nil {
- var err error
l.fsnotify, err = fsnotify.NewWatcher()
if err != nil {
return
}
}
+ // test if fsnotify is running
+ err = l.fsnotify.Add("/undefined-path-123456789")
+ if err != nil {
+ if err.Error() == "inotify instance already closed" {
+ l.fsnotify, err = fsnotify.NewWatcher()
+ if err != nil {
+ return
+ }
+ }
+ }
+
l.active = true
}
// IsRunning returns true if the watcher is active, false otherwise.
func (l *lighthouse) IsRunning() bool {
+ l.mutex.Lock()
+ defer l.mutex.Unlock()
+ return l.running
+}
+
+// IsActive returns true if the watcher is active, false otherwise.
+func (l *lighthouse) IsActive() bool {
+ l.mutex.Lock()
+ defer l.mutex.Unlock()
return l.active
}
diff --git a/lighthouse_test.go b/lighthouse_test.go
index 6cd75ccb61c903c3b01dd51bbc556b8f5410e97c..218ea091b3e221e6ed318b76a76dbdd7b7c45a29 100644
--- a/lighthouse_test.go
+++ b/lighthouse_test.go
@@ -48,7 +48,7 @@ func TestRemoveWatch(t *testing.T) {
func TestNewLighthouse(t *testing.T) {
l := NewLighthouse()
assert.NotNil(t, l)
- assert.True(t, l.IsRunning())
+ assert.True(t, l.IsActive())
}
func TestIsWatched(t *testing.T) {
diff --git a/watching.go b/watching.go
index 2c9f6cd022450959e0ac1c00fe73a96a6ab0bbb2..d896c5456f4e17ee98b23671f20b733005935889 100644
--- a/watching.go
+++ b/watching.go
@@ -7,7 +7,34 @@ import (
"time"
)
-func (l *lighthouse) StartWatching() {
+// StopWatching stops watching the given file for changes
+// If the watcher is not running, an error WatcherNotRunningError is returned.
+func (l *lighthouse) StopWatching() error {
+
+ if !l.IsRunning() {
+ return WatcherNotRunningError{}
+ }
+
+ l.mutex.Lock()
+ defer l.mutex.Unlock()
+
+ close(l.quit)
+ l.running = false
+ return nil
+}
+
+// StartWatching starts watching the given file for changes
+func (l *lighthouse) StartWatching() error {
+ if l.IsRunning() {
+ return WatcherAlreadyRunningError{}
+ }
+
+ l.mutex.Lock()
+ defer l.mutex.Unlock()
+ l.quit = make(chan struct{})
+ l.running = true
+ l.checkAndInit()
+
go func() {
eventChannel := make(chan fsnotify.Event, 100)
errorChannel := make(chan error, 100)
@@ -17,7 +44,14 @@ func (l *lighthouse) StartWatching() {
go func() {
for {
+
+ l.mutex.Lock()
+ quit := l.quit
+ l.mutex.Unlock()
+
select {
+ case <-quit:
+ return
case event := <-l.fsnotify.Events:
eventChannel <- event
case err := <-l.fsnotify.Errors:
@@ -27,7 +61,14 @@ func (l *lighthouse) StartWatching() {
}()
for {
+
+ l.mutex.Lock()
+ quit := l.quit
+ l.mutex.Unlock()
+
select {
+ case <-quit:
+ return
case event := <-eventChannel:
debounceMutex.Lock()
@@ -123,8 +164,12 @@ func (l *lighthouse) StartWatching() {
debounceMutex.Unlock()
case err := <-errorChannel:
- go l.onError(err)
+ if l.onError != nil {
+ go l.onError(err)
+ }
}
}
}()
+
+ return nil
}
diff --git a/watching_test.go b/watching_test.go
index 3d8a33e4e71d4957cd0bdd3870cd077828a80310..8e176eaa265519baa2f4afe7a2795b2a59e4535b 100644
--- a/watching_test.go
+++ b/watching_test.go
@@ -143,3 +143,31 @@ func TestRecreateEvent(t *testing.T) {
t.Fail()
}
}
+
+func TestStopWatching(t *testing.T) {
+ l := NewLighthouse() // Erstellen Sie eine neue Instanz der `lighthouse`-Struktur.
+
+ // Start Watching
+ _ = l.StartWatching()
+
+ // Erlauben Sie dem System etwas Zeit, um den Watch-Prozess zu starten.
+ time.Sleep(time.Second * 1)
+ if !l.IsRunning() {
+ t.Fatal("l.active is false, but should be true after StartWatching")
+ }
+
+ // Stop Watching
+ err := l.StopWatching()
+ if err != nil {
+ t.Fatalf("StopWatching failed: %v", err)
+ }
+
+ // Überprüfen Sie, ob die Goroutine und der Watcher gestoppt wurden.
+ if l.IsRunning() {
+ t.Fatal("l.active is true, but should be false after StopWatching")
+ }
+
+ _ = l.StartWatching()
+ assert.True(t, l.IsRunning())
+
+}