Add wait flag

Author: bduffany

config.go

@@ -70,6 +70,10 @@ type Config struct {
 	// running any command. When enabled, no command should be specified.
 	PrintChanges bool `json:"printChanges,omitempty"`
 
+	// Wait specifies whether to wait for a single change and then exit without
+	// running any command. When enabled, no command should be specified.
+	Wait bool `json:"wait,omitempty"`
+
 	// TODO: FollowSymlinks
 
 	// Private fields below

godemon.go

@@ -39,6 +39,7 @@ Advanced options:
   -s, --signal         restart signal name or number (default SIGINT)
   -v, --verbose        log more info; set twice to log lower level debug info
   -p, --print-changes  print change events to stdout without running a command
+  --wait               wait for one change, then exit without running a command
 `)
 }
 
@@ -116,6 +117,10 @@ func parseConfig(args []string) (*Config, error) {
 			cfg.PrintChanges = true
 			continue
 		}
+		if arg == "--wait" {
+			cfg.Wait = true
+			continue
+		}
 
 		// Parse string flags
 		for _, spec := range []struct {
@@ -264,8 +269,11 @@ func parseConfig(args []string) (*Config, error) {
 		}
 		cfg.notifySignal = s
 	}
-	if cfg.PrintChanges {
+	if cfg.PrintChanges || cfg.Wait {
 		if len(cfg.Command) > 0 {
+			if cfg.Wait {
+				return nil, fmt.Errorf("--wait cannot be used with a command")
+			}
 			return nil, fmt.Errorf("--print-changes cannot be used with a command")
 		}
 	} else {
@@ -667,7 +675,9 @@ func (g *godemon) Start() error {
 	defer func() {
 		debugf("Removing file watchers")
 		w.Close()
-		select {} // Wait for shutdown to finish.
+		if !g.cfg.Wait {
+			select {} // Wait for shutdown to finish.
+		}
 	}()
 	g.w = w
 
@@ -695,7 +705,9 @@ func (g *godemon) Start() error {
 		notifyf("Exiting due to --dry-run flag.")
 	}
 
-	if g.cfg.PrintChanges {
+	if g.cfg.Wait {
+		g.waitForChange(addCh)
+	} else if g.cfg.PrintChanges {
 		// In print-changes mode, just print events to stdout without running a command.
 		g.handlePrintChanges(addCh, shutdownCh)
 	} else {
@@ -852,30 +864,36 @@ func (g *godemon) handleAdds(addCh chan string) {
 	}
 }
 
+func (g *godemon) handleChange(addCh chan<- string, event fsEvent) bool {
+	if g.shouldIgnore(event.Path) {
+		infof("Ignoring event: %s %q", event.Op, event.Path)
+		return false
+	}
+	infof("Got event: %s %q", event.Op, event.Path)
+
+	if g.cfg.Lockfile != nil && *g.cfg.Lockfile != "" {
+		if err := waitForLockfileRemoval(*g.cfg.Lockfile); err != nil {
+			warnf("waitForLockfileRemoval failed: %s", err)
+		}
+	}
+
+	// When creating new dirs, add them to the watch list (recursive watchers
+	// cover newly created dirs automatically).
+	if !g.w.Recursive() && event.Op&opCreate != 0 && isDir(event.Path) {
+		addCh <- event.Path
+	}
+	return true
+}
+
 func (g *godemon) handleEvents(addCh chan<- string, restartCh chan<- struct{}, shutdownCh <-chan struct{}) {
 	for {
 		select {
 		case err := <-g.w.Errors():
 			warnf("%s", err)
 		case event := <-g.w.Events():
-			if g.shouldIgnore(event.Path) {
-				infof("Ignoring event: %s %q", event.Op, event.Path)
-				continue
-			}
-			infof("Got event: %s %q", event.Op, event.Path)
-
-			if g.cfg.Lockfile != nil && *g.cfg.Lockfile != "" {
-				if err := waitForLockfileRemoval(*g.cfg.Lockfile); err != nil {
-					warnf("waitForLockfileRemoval failed: %s", err)
-				}
+			if g.handleChange(addCh, event) {
+				restartCh <- struct{}{}
 			}
-
-			// When creating new dirs, add them to the watch list (recursive
-			// watchers cover newly created dirs automatically).
-			if !g.w.Recursive() && event.Op&opCreate != 0 && isDir(event.Path) {
-				addCh <- event.Path
-			}
-			restartCh <- struct{}{}
 		case <-shutdownCh:
 			debugf("handleEvents: got shutdown signal")
 			return
@@ -897,26 +915,33 @@ func (g *godemon) handlePrintChanges(addCh chan<- string, shutdownCh <-chan stru
 		case err := <-g.w.Errors():
 			warnf("%s", err)
 		case event := <-g.w.Events():
-			if g.shouldIgnore(event.Path) {
-				infof("Ignoring event: %s %q", event.Op, event.Path)
-				continue
-			}
-			if !isQuiet() {
+			if g.handleChange(addCh, event) && !isQuiet() {
 				// Print the change event to stdout
 				fmt.Printf("%s %s\n", event.Op, event.Path)
 			}
-			// When creating new dirs, add them to the watch list (recursive
-			// watchers cover newly created dirs automatically).
-			if !g.w.Recursive() && event.Op&opCreate != 0 && isDir(event.Path) {
-				addCh <- event.Path
-			}
 		case <-shutdownCh:
 			debugf("handlePrintChanges: got shutdown signal")
 			return
 		}
 	}
 }
 
+func (g *godemon) waitForChange(addCh chan<- string) {
+	for {
+		select {
+		case err := <-g.w.Errors():
+			warnf("%s", err)
+		case event := <-g.w.Events():
+			if g.handleChange(addCh, event) {
+				if g.cfg.PrintChanges && !isQuiet() {
+					fmt.Printf("%s %s\n", event.Op, event.Path)
+				}
+				return
+			}
+		}
+	}
+}
+
 func waitForLockfileRemoval(path string) error {
 	debugf("Waiting for removal of lockfile %s", path)
 

godemon_test.go

@@ -238,6 +238,41 @@ func TestParseThrottleFlag(t *testing.T) {
 	}
 }
 
+func TestWaitExitsOnWatchedChange(t *testing.T) {
+	ws := t.TempDir()
+	writeFile(t, ws, "watched.go", "")
+
+	cfg, err := parseConfig([]string{"godemon", "--wait", "--watch", ws, "--only", "*.go", "--ignore", "ignored.go", "--no-gitignore"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	done := make(chan error, 1)
+	go func() {
+		done <- (&godemon{cfg: cfg}).Start()
+	}()
+
+	// An ignored change should leave wait mode running.
+	time.Sleep(500 * time.Millisecond)
+	writeFile(t, ws, "ignored.go", "")
+	select {
+	case err := <-done:
+		t.Fatalf("wait exited on ignored change: %s", err)
+	case <-time.After(250 * time.Millisecond):
+	}
+
+	// A watched change should make wait mode return successfully.
+	writeFile(t, ws, "watched.go", "changed")
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatal(err)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("timed out waiting for watched change")
+	}
+}
+
 func TestRestartOnCreate(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()