targets: database only — remove ping.list/tcp.list and the import inbox

Targets live in SQLite and change in exactly one place: the web UI under
--edit. The targets/ inbox from 1.1.0 was a second write path that worked in
read-only mode, bypassing the --edit gate; it and the list parser are gone.

- Removed: ingest.go, parseListFile/parseListLine, Store.ImportTargets,
  Config.TargetsDir, targets/*.example. fogping no longer creates targets/.
- The demo target is seeded through CreateTarget.
- normalizeTarget, now the only input gate, gets a table test and a fuzz
  target in place of the list-parser ones.
- 1.0.x databases still migrate: legacy rows come out inactive and re-adding
  the same name restores the history (tested). README documents both upgrade
  routes (via 1.1.0, or re-add by name).
- README: inbox section, echo examples and the echo claim in all 17 language
  blurbs removed; links and wording updated for 1.1.1.

Author: githubflyideas

README.md

@@ -3,20 +3,17 @@ package main
 import (
 	"fmt"
 	"net"
-	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"unicode"
 	"unicode/utf8"
 )
 
-// Program parameters are constants. Targets live in SQLite (the targets table);
-// targets/*.list files are only an import inbox — see ingest.go.
+// Program parameters are constants. Targets live in SQLite (the targets table) and
+// are changed only through the web UI, when started with --edit.
 type Config struct {
 	Listen        string
 	DataDir       string
-	TargetsDir    string
 	Probe         ProbeCfg
 	HotDays       int  // full samples kept this long
 	RetentionDays int  // downsampled data kept this long
@@ -27,7 +24,6 @@ func defaultConfig() *Config {
 	return &Config{
 		Listen:        "0.0.0.0:8518",
 		DataDir:       "./data",
-		TargetsDir:    "./targets",
 		Probe:         ProbeCfg{IntervalSec: 60, Packets: 20, GapMs: 50, TimeoutMs: 1000},
 		HotDays:       2,  // raw samples: enough for the sub-day windows
 		RetentionDays: 40, // hourly rollups; --days overrides
@@ -51,8 +47,8 @@ type ProbeCfg struct {
 	TimeoutMs   int
 }
 
-// normalizeTarget is the single validation gate: web CRUD and list import both
-// pass through it, so the DB never holds a target the prober can't run.
+// normalizeTarget is the single validation gate for the web API, so the DB never
+// holds a target the prober can't run.
 func normalizeTarget(t *TargetCfg) error {
 	t.Type = strings.TrimSpace(t.Type)
 	t.Host = strings.TrimSpace(t.Host)
@@ -99,80 +95,3 @@ func targetAddr(t TargetCfg) string {
 	}
 	return t.Host
 }
-
-// parseListFile reads one list file into validated targets. Any bad line rejects
-// the whole file: a half-imported list is harder to reason about than none.
-func parseListFile(path, typ string) ([]TargetCfg, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	var out []TargetCfg
-	seen := map[string]bool{}
-	for ln, line := range strings.Split(string(raw), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		t, err := parseListLine(line, typ)
-		if err == nil {
-			err = normalizeTarget(&t)
-		}
-		if err == nil && seen[t.Name] {
-			err = fmt.Errorf("duplicate name %q", t.Name)
-		}
-		if err != nil {
-			return nil, fmt.Errorf("%s line %d: %w", filepath.Base(path), ln+1, err)
-		}
-		seen[t.Name] = true
-		out = append(out, t)
-	}
-	return out, nil
-}
-
-// line format: host[:port]  [name...]  [pace=fast|slow] [interval=sec]
-func parseListLine(line, typ string) (TargetCfg, error) {
-	t := TargetCfg{Type: typ}
-	fields := strings.Fields(line)
-	if len(fields) == 0 { // fuzz 发现:纯空白行会越界 —— 上游会挡,但函数自身必须皮实
-		return t, fmt.Errorf("empty line")
-	}
-	addr := fields[0]
-	if typ == "tcp" {
-		host, portStr, err := net.SplitHostPort(addr)
-		if err != nil {
-			return t, fmt.Errorf("tcp target %q must be host:port", addr)
-		}
-		port, err := strconv.Atoi(portStr)
-		if err != nil || port <= 0 {
-			return t, fmt.Errorf("tcp target %q: bad port", addr)
-		}
-		t.Host, t.Port = host, port
-	} else {
-		t.Host = addr
-	}
-	var nameParts []string
-	for _, f := range fields[1:] {
-		k, v, isKV := strings.Cut(f, "=")
-		if !isKV {
-			nameParts = append(nameParts, f)
-			continue
-		}
-		switch k {
-		case "pace":
-			t.Pace = v
-		case "interval":
-			n, err := strconv.Atoi(v)
-			if err != nil || n <= 0 {
-				return t, fmt.Errorf("interval=%q invalid", v)
-			}
-			t.IntervalSec = n
-		} // unknown k=v silently ignored: forward compatibility
-	}
-	if len(nameParts) > 0 {
-		t.Name = strings.Join(nameParts, " ")
-	} else {
-		t.Name = addr
-	}
-	return t, nil
-}

config.go

@@ -7,22 +7,9 @@ import (
 	"strings"
 	"testing"
 	"time"
+	"unicode/utf8"
 )
 
-func TestParseListLine(t *testing.T) {
-	tt, err := parseListLine("59.43.247.1 HK CN2 pace=fast", "icmp")
-	if err != nil || tt.Name != "HK CN2" || tt.Pace != "fast" {
-		t.Fatalf("icmp line: %+v %v", tt, err)
-	}
-	tt, err = parseListLine("10.0.0.5:443 gw interval=30", "tcp")
-	if err != nil || tt.Host != "10.0.0.5" || tt.Port != 443 || tt.IntervalSec != 30 {
-		t.Fatalf("tcp line: %+v %v", tt, err)
-	}
-	if _, err := parseListLine("noport name", "tcp"); err == nil {
-		t.Fatal("tcp without port should fail")
-	}
-}
-
 func TestProbeParams(t *testing.T) {
 	g := ProbeCfg{IntervalSec: 60, Packets: 20}
 	if iv, pk := probeParams(TargetCfg{Pace: "fast"}, g); iv.Seconds() != 15 || pk != 30 {
@@ -69,22 +56,65 @@ func BenchmarkCalcStats24h(b *testing.B) {
 	}
 }
 
-func FuzzParseListLine(f *testing.F) {
-	f.Add("1.2.3.4 name pace=fast", "icmp")
-	f.Add("10.0.0.5:443 gw interval=30", "tcp")
-	f.Add("host:99999 x", "tcp")
-	f.Add("::1 v6", "icmp")
-	f.Fuzz(func(t *testing.T, line, typ string) {
-		if typ != "icmp" && typ != "tcp" {
-			typ = "icmp"
+// normalizeTarget is the only gate between the web API and the targets table.
+func TestNormalizeTarget(t *testing.T) {
+	ok := []TargetCfg{
+		{Host: " 59.43.247.1 ", Name: "HK CN2", Pace: "fast"},
+		{Type: "tcp", Host: "10.0.0.5", Port: 443, IntervalSec: 30},
+		{Host: "example.com", Pace: "normal"},
+	}
+	for _, c := range ok {
+		if err := normalizeTarget(&c); err != nil {
+			t.Fatalf("%+v: %v", c, err)
 		}
-		if len(line) == 0 || line[0] == '#' {
+	}
+	c := TargetCfg{Type: "tcp", Host: "10.0.0.5", Port: 443}
+	normalizeTarget(&c)
+	if c.Name != "10.0.0.5:443" {
+		t.Fatalf("tcp default name: %q", c.Name)
+	}
+	c = TargetCfg{Host: "1.1.1.1", Pace: "normal"}
+	normalizeTarget(&c)
+	if c.Pace != "" || c.Name != "1.1.1.1" || c.Type != "icmp" {
+		t.Fatalf("defaults: %+v", c)
+	}
+	bad := []TargetCfg{
+		{Host: ""},
+		{Host: "a b"},
+		{Type: "tcp", Host: "h"},
+		{Type: "tcp", Host: "h", Port: 70000},
+		{Type: "udp", Host: "h"},
+		{Host: "h", Pace: "turbo"},
+		{Host: "h", IntervalSec: -1},
+		{Host: "h", Name: strings.Repeat("x", 65)},
+		{Host: "h", Name: "a\x00b"},
+	}
+	for _, c := range bad {
+		if err := normalizeTarget(&c); err == nil {
+			t.Fatalf("accepted %+v", c)
+		}
+	}
+}
+
+func FuzzNormalizeTarget(f *testing.F) {
+	f.Add("icmp", "1.1.1.1", 0, "", "fast", 0)
+	f.Add("tcp", "10.0.0.5", 443, "gw", "", 30)
+	f.Add("", " ", -1, "\x00", "normal", 99999)
+	f.Fuzz(func(t *testing.T, typ, host string, port int, name, pace string, iv int) {
+		c := TargetCfg{Type: typ, Host: host, Port: port, Name: name, Pace: pace, IntervalSec: iv}
+		if normalizeTarget(&c) != nil {
 			return
 		}
-		// 只要求不 panic、不接受空 host
-		tt, err := parseListLine(line, typ)
-		if err == nil && tt.Host == "" {
-			t.Fatalf("accepted empty host: %q", line)
+		// whatever gets in must be something the prober can run and the UI can show
+		switch {
+		case c.Host == "" || strings.ContainsAny(c.Host, " \t\n"):
+			t.Fatalf("bad host accepted: %q", c.Host)
+		case c.Type != "icmp" && c.Type != "tcp":
+			t.Fatalf("bad type accepted: %q", c.Type)
+		case c.Type == "tcp" && (c.Port < 1 || c.Port > 65535):
+			t.Fatalf("bad port accepted: %d", c.Port)
+		case c.Name == "" || utf8.RuneCountInString(c.Name) > 64:
+			t.Fatalf("bad name accepted: %q", c.Name)
 		}
 	})
 }

fogping_test.go

@@ -50,12 +50,8 @@ func main() {
 	if err != nil {
 		log.Fatalf("store init failed: %v", err)
 	}
-	os.MkdirAll(cfg.TargetsDir, 0o755)
-	if _, err := ingestLists(cfg.TargetsDir, store); err != nil {
-		log.Printf("ingest: %v", err)
-	}
 	if n, err := store.TargetRows(); err == nil && n == 0 {
-		if err := store.ImportTargets([]TargetCfg{demoTarget}); err == nil {
+		if _, err := store.CreateTarget(demoTarget); err == nil {
 			log.Printf("new database — seeded a demo target (www.google.com)")
 		}
 	}
@@ -67,7 +63,6 @@ func main() {
 	}
 	stop := make(chan struct{})
 	go store.flushLoop(stop)
-	go ingestLoop(cfg.TargetsDir, store, run, stop)
 	go housekeeping(cfg, store, stop)
 
 	mode := "read-only targets (restart with --edit to change them in the web UI)"
@@ -77,7 +72,7 @@ func main() {
 	log.Printf("fogping %s up · %d targets · %s · listening on %s · data in %s · %d-day retention",
 		version, len(run.Targets()), mode, cfg.Listen, cfg.DataDir, cfg.RetentionDays)
 	if len(run.Targets()) == 0 {
-		log.Printf(`no active targets — add them with --edit, or: echo "1.2.3.4 my-link" >> %s/ping.list`, cfg.TargetsDir)
+		log.Printf("no active targets — restart with --edit and add them in the web UI")
 	}
 	log.Printf("➜  open http://localhost%s for the smoke graph", portOf(cfg.Listen))
 	if len(users) == 0 {

ingest.go

@@ -6,8 +6,8 @@ import (
 	"sync"
 )
 
-// Runner owns the set of running probe loops, keyed by target id. Every change —
-// web edit, list import — goes through Reload, which diffs the DB against what is
+// Runner owns the set of running probe loops, keyed by target id. Every change
+// goes through Reload, which diffs the DB against what is
 // running. One mutex, one writer path; the web handlers only read snapshots.
 type Runner struct {
 	mu    sync.Mutex