fix(agent): scan neighbors per interface with own timeout (#1388)

The neighbor scan ran as a single shell loop over all interfaces with one shared 10 s timeout, and the partial output was discarded when the deadline killed it. A slow 5 GHz radio on a DFS channel (UniFi 6 Lite, mt7621) starved the whole loop, so the unit reported no neighbors at all. Each interface now scans as its own command with its own 8 s budget.

Refs #1338

Author: gnacho

agent/probe/local.go

@@ -445,16 +445,30 @@ func (p *Prober) probeWireless(ctx context.Context, full bool) *WirelessData {
 				p.radiosMu.Unlock()
 			}
 		}
+		// `iw dev` a secas, barato y estable: alimenta con UN solo spawn los
+		// BSSIDs propios (#1087) y la lista de interfaces a escanear (#1338).
+		iwDev := p.runBest(ctx, CmdIwDev, 5*time.Second)
 		// Scan pasivo de vecinos (#452): SOLO en sondeo completo y con
 		// throttle (#591) para no sacar la radio del canal en cada push.
-		if p.scanDue() {
-			if out := p.runBest(ctx, CmdScan, 10*time.Second); out != "" {
-				wd.Scans = ParseScan(out)
+		// #1338: un comando POR INTERFAZ, cada una con su propio presupuesto
+		// (8 s). Antes el bucle completo compartía un timeout de 10 s y, al
+		// expirar, la salida parcial se descartaba entera: una radio lenta
+		// (5 GHz en canal DFS, scan pasivo canal a canal) dejaba la unidad
+		// sin NINGÚN vecino aunque las demás interfaces sí hubieran
+		// escaneado con éxito.
+		if p.scanDue() && iwDev != "" {
+			var sb strings.Builder
+			for _, iface := range IwDevIfaces(iwDev) {
+				sb.WriteString("==IFACE==" + iface + "\n")
+				sb.WriteString(p.runBest(ctx, CmdScanIface(iface), scanIfaceTimeout))
+			}
+			if scans := ParseScan(sb.String()); len(scans) > 0 {
+				wd.Scans = scans
 			}
 		}
-		// BSSIDs propios (#1087): `iw dev` sin scan, barato y estable.
-		if out := p.runBest(ctx, CmdIwDev, 5*time.Second); out != "" {
-			wd.OwnBssids = ParseIwDev(out)
+		// BSSIDs propios (#1087), del mismo `iw dev` de arriba.
+		if iwDev != "" {
+			wd.OwnBssids = ParseIwDev(iwDev)
 		}
 		// Survey en vivo (#1214): ocupación por canal para la lente "Ahora"
 		// del server en unidades agent-only (sin SSH). Texto crudo: el

agent/probe/probe.go

@@ -95,6 +95,14 @@ const (
 	// CmdScan (#452): scan pasivo de vecinos con `iw dev`. Lista interfaces,
 	// emite "==IFACE==<iface>" antes de cada scan y parsea BSS/freq/signal/SSID.
 	// Si `iw` no está disponible, la sección Scans queda vacía (best-effort).
+	//
+	// DEPRECATED (#1338): el bucle monolítico corría con UN solo timeout para
+	// todas las interfaces y, al expirar, la salida parcial se descartaba
+	// entera. Una radio lenta (5 GHz en canal DFS, scan pasivo canal a canal)
+	// dejaba la unidad sin NINGÚN vecino, aunque las demás interfaces sí
+	// hubieran escaneado. El agente escanea ahora por interfaz con
+	// CmdScanIface, cada una con su propio presupuesto. Se conserva la
+	// constante por compatibilidad del módulo (consumidores vendorizados).
 	CmdScan = `for i in $(iw dev 2>/dev/null | awk '/Interface / {print $2}'); do echo "==IFACE==$i"; iw dev "$i" scan 2>/dev/null; done`
 	// CmdSurvey (#1214): `iw dev <iface> survey dump` por interfaz, con el
 	// mismo marcador "==IFACE==" que CmdScan. El server parsea el texto
@@ -106,6 +114,13 @@ const (
 	// su MAC y SSID: fuente de los BSSIDs propios para el análisis de
 	// canales. Barato (no saca la radio del canal).
 	CmdIwDev = "iw dev 2>/dev/null"
+	// scanIfaceTimeout (#1338): presupuesto POR INTERFAZ del scan de vecinos.
+	// Una radio 5 GHz en canal DFS escanea en pasivo canal a canal y puede
+	// tardar varios segundos; con el presupuesto único de 10 s para todas,
+	// esa radio lenta mataba el bucle y se perdían también los scans ya
+	// hechos. Cada interfaz tiene ahora su propio tiempo y un fallo o un
+	// cuelgue solo vacía su propia sección.
+	scanIfaceTimeout = 8 * time.Second
 	// CmdRadioSections (#500): secciones wifi-device de UCI con su banda, para
 	// resolver "2.4 GHz" → radio0 (la relación iface→sección no sale de iwinfo).
 	CmdRadioSections = `uci -q show wireless 2>/dev/null | grep -E "=wifi-device$|\.band=|\.hwmode="`
@@ -186,6 +201,14 @@ const (
 	CmdEthtoolSFP = "ethtool -m %s 2>/dev/null || true"
 )
 
+// CmdScanIface (#1338): scan pasivo de UNA interfaz. El agente lo lanza una
+// vez por interfaz de `iw dev` (en vez del bucle monolítico de CmdScan) para
+// que cada radio tenga su propio presupuesto de tiempo y una interfaz lenta
+// o colgada no se lleve por delante los resultados de las demás.
+func CmdScanIface(iface string) string {
+	return `iw dev "` + iface + `" scan 2>/dev/null`
+}
+
 // ---------------------------------------------------------------------------
 // Shapes parseados (salida de las sondas; contrato del payload del agente)
 // ---------------------------------------------------------------------------
@@ -1785,6 +1808,19 @@ func ParseIwDev(out string) []OwnBSSID {
 	return res
 }
 
+// IwDevIfaces (#1338) lista TODAS las interfaces de `iw dev` (cualquier
+// tipo, no solo AP como ParseIwDev): son las candidatas a escanear vecinos.
+func IwDevIfaces(out string) []string {
+	var res []string
+	for _, raw := range strings.Split(out, "\n") {
+		fields := strings.Fields(strings.TrimSpace(raw))
+		if len(fields) >= 2 && fields[0] == "Interface" {
+			res = append(res, fields[1])
+		}
+	}
+	return res
+}
+
 // FreqToChannel convierte frecuencia (MHz) a número de canal 802.11.
 func FreqToChannel(freq int) int {
 	switch {

agent/probe/scan_periface_test.go

@@ -0,0 +1,128 @@
+package probe
+
+// scan_periface_test.go — #1338: el scan de vecinos se lanzaba como UN solo
+// comando (`iw dev` + bucle sobre TODAS las interfaces) con UN solo timeout
+// de 10 s. Si una interfaz escanea lento (p. ej. una radio 5 GHz en canal
+// DFS, scan pasivo canal a canal), el timeout mataba el bucle entero y la
+// salida parcial —con las interfaces que SÍ habían escaneado— se descartaba:
+// la unidad no reportaba NINGÚN vecino (UniFi 6 Lite, mt7621). Ahora el scan
+// va por interfaz, cada una con su propio presupuesto de tiempo: una que
+// falla o se cuelga deja su sección vacía y no arrastra a las demás.
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+)
+
+// runnerScanParcial simula una unidad con dos radios donde el scan de la
+// primera interfaz (5 GHz) muere por timeout y la segunda (2.4 GHz) devuelve
+// un vecino real.
+type runnerScanParcial struct {
+	fakeRunner
+}
+
+func (r runnerScanParcial) Run(ctx context.Context, cmd string, timeout time.Duration) (string, error) {
+	if cmd == CmdScanIface("phy1-ap0") {
+		return "", &fakeErr{cmd} // timeout del runner real: err y sin salida
+	}
+	return r.fakeRunner.Run(ctx, cmd, timeout)
+}
+
+// TestScanPorInterfazSobreviveAFalloParcial: con el scan de la primera
+// interfaz fallando, los vecinos de la segunda deben llegar igual.
+func TestScanPorInterfazSobreviveAFalloParcial(t *testing.T) {
+	iwDev := "phy#1\n" +
+		"\tInterface phy1-ap0\n" +
+		"\t\taddr 62:22:32:5b:5c:99\n" +
+		"\t\tssid I1_LAN\n" +
+		"\t\ttype AP\n" +
+		"\t\tchannel 60 (5300 MHz), width: 80 MHz, center1: 5290 MHz\n" +
+		"phy#0\n" +
+		"\tInterface phy0-ap0\n" +
+		"\t\taddr 60:22:32:5b:5c:98\n" +
+		"\t\tssid I1_LAN\n" +
+		"\t\ttype AP\n" +
+		"\t\tchannel 5 (2432 MHz), width: 20 MHz, center1: 2432 MHz\n"
+	// Salida real del scan en la U6 Lite del reportero (#1338), con las dos
+	// líneas "last seen" (la de cabecera con [boottime] y la de señal).
+	scan2g := "BSS c4:eb:39:0c:2b:c1(on phy0-ap0)\n" +
+		"\tlast seen: 275247.799s [boottime]\n" +
+		"\tTSF: 901954671988 usec (10d, 10:32:34)\n" +
+		"\tfreq: 2437.0\n" +
+		"\tbeacon interval: 100 TUs\n" +
+		"\tcapability: ESS (0x1011)\n" +
+		"\tsignal: -67.00 dBm\n" +
+		"\tlast seen: 2140 ms ago\n" +
+		"\tSSID: Vecino_24\n"
+	run := runnerScanParcial{fakeRunner{outs: map[string]string{
+		CmdIwDev:                 iwDev,
+		CmdScanIface("phy0-ap0"): scan2g,
+	}}}
+	p := NewProber(run, Options{})
+
+	pl := p.Build(context.Background(), "u6lite", "test")
+	if pl.Data.Wireless == nil {
+		t.Fatal("sección wireless ausente")
+	}
+	scans := pl.Data.Wireless.Scans
+	if len(scans) != 1 {
+		t.Fatalf("el fallo del scan 5 GHz no debe arrastrar al 2.4 GHz: %+v", scans)
+	}
+	sc := scans[0]
+	if sc.Iface != "phy0-ap0" || sc.BSSID != "C4:EB:39:0C:2B:C1" || sc.SSID != "Vecino_24" || sc.Channel != 6 || sc.Signal != -67 {
+		t.Fatalf("vecino mal parseado: %+v", sc)
+	}
+	// Los BSSIDs propios salen del MISMO `iw dev` (sin segundo spawn).
+	if len(pl.Data.Wireless.OwnBssids) != 2 {
+		t.Fatalf("ownBssids perdidos: %+v", pl.Data.Wireless.OwnBssids)
+	}
+}
+
+// TestScanPorInterfazSinIw: sin `iw` en el equipo, ni scans ni BSSIDs propios
+// (best-effort, como antes).
+func TestScanPorInterfazSinIw(t *testing.T) {
+	p := NewProber(fakeRunner{outs: map[string]string{}}, Options{})
+	pl := p.Build(context.Background(), "sin-iw", "test")
+	if pl.Data.Wireless != nil && len(pl.Data.Wireless.Scans) != 0 {
+		t.Fatalf("sin iw no puede haber scans: %+v", pl.Data.Wireless.Scans)
+	}
+}
+
+// TestCmdScanIface: el comando por interfaz cita el nombre (como hacía el
+// bucle viejo con "$i").
+func TestCmdScanIface(t *testing.T) {
+	cmd := CmdScanIface("phy0-ap0")
+	if !strings.Contains(cmd, `iw dev "phy0-ap0" scan`) {
+		t.Fatalf("comando inesperado: %q", cmd)
+	}
+}
+
+// TestScanPorInterfazThrottle: el throttle (scanDue) sigue gobernando el
+// scan aunque ahora se lance por interfaz: 2 interfaces = 2 comandos en la
+// primera Build y 0 en la segunda (dentro del intervalo).
+func TestScanPorInterfazThrottle(t *testing.T) {
+	iwDev := "phy#0\n" +
+		"\tInterface phy0-ap0\n\t\taddr 60:22:32:5b:5c:98\n\t\ttype AP\n" +
+		"\tInterface phy0-ap1\n\t\taddr 62:22:32:5b:5c:98\n\t\ttype AP\n"
+	run := &countingRunner{fakeRunner: fakeRunner{outs: map[string]string{
+		CmdIwDev: iwDev,
+	}}}
+	p := NewProber(run, Options{})
+	ctx := context.Background()
+
+	p.Build(ctx, "rt", "test")
+	if run.scanCalls != 2 {
+		t.Fatalf("primera Build debería escanear las 2 interfaces, scanCalls=%d", run.scanCalls)
+	}
+	p.Build(ctx, "rt", "test")
+	if run.scanCalls != 2 {
+		t.Fatalf("segunda Build dentro del intervalo NO debería escanear, scanCalls=%d", run.scanCalls)
+	}
+	p.ForceScan()
+	p.Build(ctx, "rt", "test")
+	if run.scanCalls != 4 {
+		t.Fatalf("ForceScan debería reescanear las 2 interfaces, scanCalls=%d", run.scanCalls)
+	}
+}

agent/probe/scan_throttle_test.go

@@ -7,29 +7,33 @@ package probe
 
 import (
 	"context"
+	"strings"
 	"testing"
 	"time"
 )
 
-// countingRunner cuenta las invocaciones de CmdScan sobre un fakeRunner.
+// countingRunner cuenta los scans por interfaz (#1338: antes era UNA llamada
+// a CmdScan; ahora es un `iw dev <iface> scan` por interfaz) sobre un
+// fakeRunner.
 type countingRunner struct {
 	fakeRunner
 	scanCalls int
 }
 
 func (r *countingRunner) Run(ctx context.Context, cmd string, timeout time.Duration) (string, error) {
-	if cmd == CmdScan {
+	if strings.HasPrefix(cmd, `iw dev "`) && strings.HasSuffix(cmd, `" scan 2>/dev/null`) {
 		r.scanCalls++
 	}
 	return r.fakeRunner.Run(ctx, cmd, timeout)
 }
 
-// newScanProber devuelve un Prober cuyo runner solo responde a CmdScan (el
-// resto de sondas falla y Build sigue sin scans/radios: suficiente para
-// probar el throttle).
+// newScanProber devuelve un Prober cuyo runner solo responde a `iw dev` (una
+// interfaz wlan0) y a su scan (el resto de sondas falla y Build sigue sin
+// radios: suficiente para probar el throttle).
 func newScanProber() (*Prober, *countingRunner) {
 	run := &countingRunner{fakeRunner: fakeRunner{outs: map[string]string{
-		CmdScan: "==IFACE==wlan0\nBSS 00:11:22:33:44:55\n\tfreq: 2412\n\tsignal: -45.00 dBm\n\tSSID: test\n",
+		CmdIwDev:              "phy#0\n\tInterface wlan0\n\t\taddr 00:11:22:33:44:66\n\t\ttype AP\n",
+		CmdScanIface("wlan0"): "BSS 00:11:22:33:44:55\n\tfreq: 2412\n\tsignal: -45.00 dBm\n\tSSID: test\n",
 	}}}
 	return NewProber(run, Options{}), run
 }