FileWatcherStart.go

package devwatch

import (
	"sync"

	"github.com/fsnotify/fsnotify"
)

func (h *DevWatch) FileWatcherStart(wg *sync.WaitGroup) {
	if h.shouldWatch != nil && !h.shouldWatch() {
		//h.Logger("Skipping file watcher - not a valid Go project")
		<-h.ExitChan
		wg.Done()
		return
	}

	w := h.Watcher()
	if w == nil {
		if watcher, err := fsnotify.NewWatcher(); err != nil {
			h.Logger("Error New Watcher: ", err)
			return
		} else {
			h.SetWatcher(watcher)
			w = watcher
		}
	}

	// Register existing directories BEFORE starting the event loop.
	// Events queued by the OS during scanning are discarded below to prevent
	// spurious recompile/reload cycles at startup.
	h.watcherMu.RLock()
	var dirs []string
	if len(h.directories) > 0 {
		dirs = make([]string, len(h.directories))
		copy(dirs, h.directories)
	}
	h.watcherMu.RUnlock()

	for _, dir := range dirs {
		if err := h.scanAndRegisterDirectory(dir); err != nil {
			h.Logger("Error scanning directory:", dir, err)
		}
	}

	// Drain events buffered during the scan phase so startup artifacts
	// (e.g. inotify CREATE events from a prior go build) never reach handlers.
	h.drainStartupEvents()

	h.Logger("Listening for File Changes ...")

	// Start the event processing loop only AFTER the initial scan is complete.
	go h.watchEvents()

	// Wait for exit signal after watching is active
	<-h.ExitChan
	w.Close()
	wg.Done()
}

// drainStartupEvents discards any OS events that accumulated in the watcher
// channel during the initial directory scan. This prevents those events from
// triggering spurious compilations or reloads on startup.
func (h *DevWatch) drainStartupEvents() {
	w := h.Watcher()
	if w == nil {
		return
	}
	for {
		select {
		case <-w.Events:
		case <-w.Errors:
		default:
			return
		}
	}
}