Save partial results on Ctrl+C instead of discarding them

SamNet-dev · SamNet-dev · commit a4082768da79 · 2026-03-05T22:01:07.000-06:00
Handle SIGINT gracefully across all commands: stop dispatching new
jobs, collect completed results, and write them to the output file.
diff --git a/cmd/chain.go b/cmd/chain.go
@@ -1,7 +1,10 @@
 package main
 
 import (
+	"context"
 	"fmt"
+	"os"
+	"os/signal"
 	"strconv"
 	"strings"
 	"time"
@@ -227,6 +230,14 @@ func runChain(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("--output / -o flag is required")
 	}
 
-	report := scanner.RunChain(ips, workers, steps, newProgressFactory())
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
+	report := scanner.RunChainCtx(ctx, ips, workers, steps, newProgressFactory())
+
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results to %s\n", outputFile)
+	}
+
 	return scanner.WriteChainReport(report, outputFile)
 }
diff --git a/cmd/doh_e2e.go b/cmd/doh_e2e.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -43,9 +47,16 @@ func runDoHE2E(cmd *cobra.Command, args []string) error {
 	ports := scanner.PortPool(30000, workers)
 	check := scanner.DoHDnsttCheckBin(bin, domain, pubkey, testURL, proxyAuth, ports)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(urls, workers, dur, check, newProgress("doh/e2e"))
+	results := scanner.RunPoolCtx(ctx, urls, workers, dur, check, newProgress("doh/e2e"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("doh/e2e", results, elapsed, "e2e_ms")
 }
diff --git a/cmd/doh_resolve.go b/cmd/doh_resolve.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -30,9 +34,16 @@ func runDoHResolve(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.DoHResolveCheck(domain, count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(urls, workers, dur, check, newProgress("doh/resolve"))
+	results := scanner.RunPoolCtx(ctx, urls, workers, dur, check, newProgress("doh/resolve"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("doh/resolve", results, elapsed, "resolve_ms")
 }
diff --git a/cmd/doh_tunnel.go b/cmd/doh_tunnel.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -30,9 +34,16 @@ func runDoHTunnel(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.DoHTunnelCheck(domain, count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(urls, workers, dur, check, newProgress("doh/resolve/tunnel"))
+	results := scanner.RunPoolCtx(ctx, urls, workers, dur, check, newProgress("doh/resolve/tunnel"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("doh/resolve/tunnel", results, elapsed, "resolve_ms")
 }
diff --git a/cmd/e2e_dnstt.go b/cmd/e2e_dnstt.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -43,9 +47,16 @@ func runE2EDnstt(cmd *cobra.Command, args []string) error {
 	ports := scanner.PortPool(30000, workers)
 	check := scanner.DnsttCheckBin(bin, domain, pubkey, testURL, proxyAuth, ports)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("e2e/dnstt"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("e2e/dnstt"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("e2e/dnstt", results, elapsed, "e2e_ms")
 }
diff --git a/cmd/e2e_slipstream.go b/cmd/e2e_slipstream.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -42,9 +46,16 @@ func runE2ESlipstream(cmd *cobra.Command, args []string) error {
 	ports := scanner.PortPool(30000, workers)
 	check := scanner.SlipstreamCheckBin(bin, domain, certPath, testURL, proxyAuth, ports)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("e2e/slipstream"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("e2e/slipstream"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("e2e/slipstream", results, elapsed, "e2e_ms")
 }
diff --git a/cmd/edns.go b/cmd/edns.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -30,9 +34,16 @@ func runEDNS(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.EDNSCheck(domain, count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("edns"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("edns"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("edns", results, elapsed, "edns_max")
 }
diff --git a/cmd/nxdomain.go b/cmd/nxdomain.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -26,9 +30,16 @@ func runNXDomain(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.NXDomainCheck(count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("nxdomain"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("nxdomain"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("nxdomain", results, elapsed, "hijack")
 }
diff --git a/cmd/ping.go b/cmd/ping.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -26,9 +30,16 @@ func runPing(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.PingCheck(count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("ping"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("ping"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("ping", results, elapsed, "ping_ms")
 }
diff --git a/cmd/resolve.go b/cmd/resolve.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -30,9 +34,16 @@ func runResolve(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.ResolveCheck(domain, count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("resolve"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("resolve"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("resolve", results, elapsed, "resolve_ms")
 }
diff --git a/cmd/scan.go b/cmd/scan.go
@@ -1,8 +1,10 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"os"
+	"os/signal"
 	"sort"
 	"strings"
 	"time"
@@ -167,10 +169,17 @@ func runScan(cmd *cobra.Command, args []string) error {
 
 	printBanner(len(ips), dohMode, domain, steps)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	scanStart := time.Now()
-	report := scanner.RunChainQuiet(ips, workers, steps, newProgressFactoryWithTotal(len(steps)))
+	report := scanner.RunChainQuietCtx(ctx, ips, workers, steps, newProgressFactoryWithTotal(len(steps)))
 	totalTime := time.Since(scanStart)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n\n  %s⚠ Interrupted — saving partial results to %s%s\n", colorYellow, outputFile, colorReset)
+	}
+
 	printSummary(report, topN, totalTime)
 
 	return scanner.WriteChainReport(report, outputFile)
diff --git a/cmd/tunnel.go b/cmd/tunnel.go
@@ -1,6 +1,10 @@
 package main
 
 import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
 	"time"
 
 	"github.com/SamNet-dev/findns/internal/scanner"
@@ -30,9 +34,16 @@ func runTunnel(cmd *cobra.Command, args []string) error {
 	dur := time.Duration(timeout) * time.Second
 	check := scanner.TunnelCheck(domain, count)
 
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer stop()
+
 	start := time.Now()
-	results := scanner.RunPool(ips, workers, dur, check, newProgress("resolve/tunnel"))
+	results := scanner.RunPoolCtx(ctx, ips, workers, dur, check, newProgress("resolve/tunnel"))
 	elapsed := time.Since(start)
 
+	if ctx.Err() != nil {
+		fmt.Fprintf(os.Stderr, "\n⚠ Interrupted — saving partial results\n")
+	}
+
 	return writeReport("resolve/tunnel", results, elapsed, "resolve_ms")
 }
diff --git a/internal/scanner/chain.go b/internal/scanner/chain.go
diff --git a/internal/scanner/worker.go b/internal/scanner/worker.go
