Fix reload race and tiering bugs, time-window ring, --listen, --help, tests

store:
- in-memory ring is a 24h time window instead of a 1440-round cap: pace=fast
  held only 6h and interval=5 only 2h, so last_24h stats and the detector's
  4h baseline silently shrank. Trimming is a reslice; out-of-order rounds
  from a reload overlap are inserted in order.
- Downsample no longer judges a whole day by its first round: a lossy first
  round (<=4 replies) left the day un-downsampled forever.
- Tier remembers files it already downsampled instead of re-reading every
  cold day of every target each night.
- ReadRange walks calendar days from local midnight; stepping from `from`
  skipped the last day's file when to's time of day was earlier.

reload: cfg.Targets is written by the reload loop and read by /api/targets;
access now goes through SetTargets/TargetList (data race, seen with -race).

web: at most 5 concurrent data requests (others wait up to 30s, then 503);
sessions expire 7200s after login; logout revokes the token; the page goes
back to /login on 401.

cli:
- --listen host:port (default 0.0.0.0:8517), configurable again since the
  config file went away in v2.1; --localhost keeps the --listen port.
- --help with copy-ready examples (quick start in /home/pingping, login,
  --listen, nohup, targets via vim/echo, ICMP permission); also
  './pingping help'. A flag placed after user=/passwd= says to put it first.

docs: README gets mkdir + nohup in the install block and a Parameters
section at the bottom; docs/advance.readme.md (systemd, /opt, reverse
proxy) removed; targets/*.example no longer say "restart to apply".

tests: store, web, probe, reload/config, detector, help (every flag
documented, every example accepted by the real parsers); coverage 16% -> 75%.
CI runs gofmt, vet and go test -race.

Author: githubflyideas

.github/workflows/test.yml

@@ -0,0 +1,16 @@
+name: test
+on:
+  push:
+    branches: [main]
+  pull_request:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with: { go-version: '1.22' }
+      - name: gofmt
+        run: test -z "$(gofmt -l .)" || (gofmt -l . && exit 1)
+      - run: go vet ./...
+      - run: go test -race -count=1 ./...

README.md

@@ -12,12 +12,15 @@ Just scp and run
 
 ```bash
 #install
-cd /home/pingping/
+mkdir -p /home/pingping && cd /home/pingping
 wget https://github.com/githubflyideas/pingping/releases/download/v2.11.2/pingping-v2.11.2-linux-amd64.tar.gz
 tar -zxvf pingping-v2.11.2-linux-amd64.tar.gz
 
 #run
 ./pingping user=admin passwd=admin
+
+#run in background
+nohup ./pingping user=admin passwd=admin > pingping.log 2>&1 &
 ```
 Open http://localhost:8517 and watch your first puff of network smoke.
 
@@ -50,3 +53,34 @@ Latest [Releases](https://github.com/githubflyideas/pingping/releases)
 
 
 apache 2.0
+
+
+## Parameters
+
+`./pingping --help` prints all of this with copy-ready examples.
+
+```
+./pingping [flags] [user=NAME[,NAME2...] passwd=PASS[,PASS2...]]
+```
+
+| Parameter | Default | Meaning |
+|---|---|---|
+| `--listen host:port` | `0.0.0.0:8517` | Web UI address. `0.0.0.0` = all interfaces; an IP binds one interface only |
+| `--localhost` | off | Bind `127.0.0.1` only (this machine only), keeping the `--listen` port |
+| `--version` | | Print version and exit |
+| `--help` | | Help with examples (also `./pingping help`) |
+| `user=a,b passwd=x,y` | no login | Turn the login page on. Users and passwords pair by position and the counts must match. A login lasts 2 hours; a restart logs everyone out |
+
+Flags come first, `user=` / `passwd=` last:
+
+```
+./pingping                                              # 0.0.0.0:8517, no login
+./pingping --listen 0.0.0.0:9000 user=admin passwd=admin
+./pingping --localhost                                  # 127.0.0.1:8517
+nohup ./pingping user=admin passwd=admin > pingping.log 2>&1 &   # background; stop with: pkill -x pingping
+```
+
+Everything else is fixed: `targets/` and `data/` sit in the directory you start it in (`/home/pingping`), the default pace
+probes every 60 s with 20 packets, full samples are kept 30 days and data is deleted after 300 days.
+Targets are not parameters — edit `targets/ping.list` / `targets/tcp.list`; changes apply within 3 seconds.
+

config.go

@@ -1,13 +1,14 @@
 package main
 
 import (
-		"fmt"
+	"fmt"
 	"net"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 )
 
 // pingping 2.0: a probe, text files, and a smoke graph. Nothing else.
@@ -21,6 +22,23 @@ type Config struct {
 	Probe         ProbeCfg
 	HotDays       int // full samples kept this long
 	RetentionDays int // downsampled data kept this long
+
+	// Targets is written by the reload loop while web handlers read it. Once the
+	// program is running, go through SetTargets / TargetList only.
+	tmu sync.RWMutex
+}
+
+func (c *Config) SetTargets(ts []TargetCfg) {
+	c.tmu.Lock()
+	c.Targets = ts
+	c.tmu.Unlock()
+}
+
+// TargetList returns a copy that is safe to use after a concurrent reload.
+func (c *Config) TargetList() []TargetCfg {
+	c.tmu.RLock()
+	defer c.tmu.RUnlock()
+	return append([]TargetCfg(nil), c.Targets...)
 }
 
 func defaultConfig() *Config {
@@ -99,7 +117,6 @@ func validateTargets(cfg *Config) error {
 	return nil
 }
 
-
 // loadTargetLists reads targets/ping.list and tcp.list.
 // line format: host[:port]  [name...]  [pace=fast|slow] [interval=sec]
 func loadTargetLists(dir string) ([]TargetCfg, error) {
@@ -169,4 +186,3 @@ func parseListLine(line, typ string) (TargetCfg, error) {
 	}
 	return t, nil
 }
-

docs/advance.readme.md

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"strings"
+	"testing"
+)
+
+func helpOutput() string {
+	var b bytes.Buffer
+	usage(&b)
+	return b.String()
+}
+
+// Every flag the program defines must be documented in --help.
+func TestHelpDocumentsEveryFlag(t *testing.T) {
+	out := helpOutput()
+	flag.VisitAll(func(f *flag.Flag) {
+		if !strings.HasPrefix(f.Name, "test.") && !strings.Contains(out, "--"+f.Name) {
+			t.Errorf("--%s missing from --help", f.Name)
+		}
+	})
+	if strings.Contains(out, "%!") {
+		t.Fatal("broken format verb in help text")
+	}
+}
+
+// Every ./pingping example in --help must be accepted by the real parsers, so
+// the help cannot drift from the code.
+func TestHelpExamplesParse(t *testing.T) {
+	n := 0
+	for _, line := range strings.Split(helpOutput(), "\n") {
+		line = strings.TrimPrefix(strings.TrimSpace(line), "nohup ")
+		if !strings.HasPrefix(line, "./pingping") || strings.HasPrefix(line, "./pingping [") {
+			continue
+		}
+		n++
+		fs := flag.NewFlagSet("example", flag.ContinueOnError)
+		listen := fs.String("listen", defaultConfig().Listen, "")
+		local := fs.Bool("localhost", false, "")
+		fs.Bool("version", false, "")
+		args := strings.Fields(strings.SplitN(strings.SplitN(line, "#", 2)[0], ">", 2)[0])[1:]
+		if err := fs.Parse(args); err != nil {
+			t.Errorf("%q: %v", line, err)
+			continue
+		}
+		if _, err := parseAuthArgs(fs.Args()); err != nil {
+			t.Errorf("%q: %v", line, err)
+		}
+		if _, err := listenAddr(*listen, *local); err != nil {
+			t.Errorf("%q: %v", line, err)
+		}
+	}
+	if n < 5 {
+		t.Fatalf("only %d examples found", n)
+	}
+}
+
+// Every echo line in --help must be a valid target line for its list.
+func TestHelpTargetLinesParse(t *testing.T) {
+	n := 0
+	for _, line := range strings.Split(helpOutput(), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "echo \"") {
+			continue
+		}
+		n++
+		body := line[len(`echo "`) : strings.Index(line[len(`echo "`):], `"`)+len(`echo "`)]
+		typ := "icmp"
+		if strings.HasSuffix(line, "tcp.list") {
+			typ = "tcp"
+		}
+		if _, err := parseListLine(body, typ); err != nil {
+			t.Errorf("%q: %v", line, err)
+		}
+	}
+	if n < 4 {
+		t.Fatalf("only %d target examples found", n)
+	}
+}
+
+func TestWantsHelp(t *testing.T) {
+	for _, a := range [][]string{{"--help"}, {"-h"}, {"help"}, {"--listen", "0.0.0.0:1", "-help"}} {
+		if !wantsHelp(a) {
+			t.Errorf("%v: want help", a)
+		}
+	}
+	if wantsHelp([]string{"user=help", "passwd=x"}) {
+		t.Error("a user named help is not a help request")
+	}
+}
+
+func TestFlagAfterAuthArgsIsExplained(t *testing.T) {
+	_, err := parseAuthArgs([]string{"user=a", "passwd=b", "--listen", "0.0.0.0:9000"})
+	if err == nil || !strings.Contains(err.Error(), "put flags first") {
+		t.Fatalf("want a put-flags-first hint, got %v", err)
+	}
+}