dimitar
0c9c07e8de
Add the scheduling layer and the watch command so gitflow can rescan
repositories on an interval and surface state changes.
Scheduler (internal/scheduler):
- Scheduler runs a callback immediately and then on a time.Ticker until
the context is cancelled; interval <= 0 means a single run
- Graceful shutdown: cancellation is never reported as an error (checked
on the first run and after every run), so Ctrl-C / SIGTERM exit cleanly
- A non-cancellation run error stops the loop and is propagated
Change detection (pkg/status):
- Changed(prev, next) compares snapshots per repository path — status,
branch, detached flag, ahead/behind, stash count, and file counts —
and returns the repositories whose observable state differs, including
repositories that newly appear
Watch command (cmd/gitflow):
- newWatchCmd validates that --interval is positive, prompts for the
parent directory on a TTY when --dir is absent, and drives the
scheduler with ScanOnce
- Each frame clears the screen on a terminal (or prints a RFC3339 header
when output is piped, so watch doubles as a lightweight logger) and
renders through the presenter
- Footer shows changed repositories since the previous frame ("▲ name:
status") and the next scan time; JSON format emits one document per
frame for scripting
- SIGINT/SIGTERM handled via signalContext for a clean stop
Testing:
- Scheduler: single run, periodic repetition, stop-on-error, pre-cancelled
context, and cancellation-during-run (no error reported)
- status.Changed: unchanged repos ignored; status, file-count, and
newly-appeared repos detected
Verified: go build, go vet, go test -race, gofmt clean; manual watch
smoke test over a scratch directory with 1s interval — frames render,
SIGINT and SIGTERM both exit 0 with no orphaned processes.
96 lines
2.6 KiB
Go
96 lines
2.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"gitea.oblak.solutions/dimitar/gitFlow/internal/app"
|
|
"gitea.oblak.solutions/dimitar/gitFlow/internal/config"
|
|
"gitea.oblak.solutions/dimitar/gitFlow/internal/presenter"
|
|
"gitea.oblak.solutions/dimitar/gitFlow/internal/scheduler"
|
|
"gitea.oblak.solutions/dimitar/gitFlow/pkg/status"
|
|
)
|
|
|
|
// newWatchCmd repeatedly scans on an interval until interrupted.
|
|
func newWatchCmd() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "watch",
|
|
Short: "Repeatedly scan repositories on an interval",
|
|
Args: cobra.NoArgs,
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
cfg, err := config.Load(cmd.Flags())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if cfg.Interval <= 0 {
|
|
return errors.New("watch requires a positive --interval (e.g. --interval 30s)")
|
|
}
|
|
// Same interactive prompt as scan, per the README.
|
|
if !cmd.Flags().Changed("dir") && isTerminal(os.Stdin) {
|
|
if d, err := promptDir(cfg.Dir); err == nil {
|
|
cfg.Dir = d
|
|
}
|
|
}
|
|
|
|
ctx, stop := signalContext()
|
|
defer stop()
|
|
|
|
a, err := app.New(cfg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opts := presenter.Options{Color: presenter.ParseColorMode(cfg.Color)}
|
|
|
|
var prev status.ScanResult
|
|
first := true
|
|
run := func(ctx context.Context) error {
|
|
result, err := a.ScanOnce(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if cfg.Format == "json" {
|
|
return presenter.Present(os.Stdout, cfg.Format, result, opts)
|
|
}
|
|
renderWatchFrame(result, prev, first, cfg, opts)
|
|
prev = result
|
|
first = false
|
|
return nil
|
|
}
|
|
|
|
sched := scheduler.New(cfg.Interval, run)
|
|
return sched.Run(ctx)
|
|
},
|
|
}
|
|
config.RegisterFlags(cmd.Flags())
|
|
return cmd
|
|
}
|
|
|
|
// renderWatchFrame clears the screen (or prints a timestamp header when
|
|
// output is not a terminal), renders the scan, and prints a footer with
|
|
// changed repositories and the next scan time.
|
|
func renderWatchFrame(result, prev status.ScanResult, first bool, cfg *config.Config, opts presenter.Options) {
|
|
if isTerminal(os.Stdout) {
|
|
fmt.Fprint(os.Stdout, "\x1b[2J\x1b[H")
|
|
} else {
|
|
fmt.Fprintf(os.Stdout, "--- %s ---\n", time.Now().Format(time.RFC3339))
|
|
}
|
|
|
|
if err := presenter.Present(os.Stdout, cfg.Format, result, opts); err != nil {
|
|
fmt.Fprintf(os.Stderr, "render: %v\n", err)
|
|
return
|
|
}
|
|
|
|
if !first {
|
|
for _, r := range status.Changed(prev, result) {
|
|
fmt.Fprintf(os.Stdout, "▲ %s: %s\n", r.Name, r.Status)
|
|
}
|
|
}
|
|
fmt.Fprintf(os.Stdout, "watching %s every %s — next scan at %s (Ctrl-C to stop)\n",
|
|
cfg.Dir, cfg.Interval, time.Now().Add(cfg.Interval).Format("15:04:05"))
|
|
}
|