fix(module): ignore control lines of non-interactive modules, warn once per run on oversize ones

commit: 2742b07d2a36bae0805c5dec91b267b944fad8b1
author: brice · 14d ago · 2026-10-09 06:34 UTC
parent: 616b0de
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +64 -8

M internal/module/control_test.go +46 -5

@@ -1,11 +1,20 @@
1	1		package module
2	2
3	3		import (
	4	+	"bytes"
4	5		"fmt"
	6	+	"log/slog"
5	7		"strings"
6	8		"testing"
7	9		)
8	10
	11	+	// newInteractive is newTest for a module that may send control lines.
	12	+	func newInteractive() (*Module, chan struct{}) {
	13	+	m, wake := newTest()
	14	+	m.Interactive = true
	15	+	return m, wake
	16	+	}
	17	+
9	18		func TestParseControlValid(t *testing.T) {
10	19		c, err := ParseControl([]byte(`{"type":"tooltip","col":2,"width":1,"title":"Steam","body":"line1\nline2"}`))
11	20		if err != nil \|\| c.Type != ControlTooltip \|\| c.Col != 2 \|\| c.Width != 1 \|\| c.Title != "Steam" \|\| c.Body != "line1\nline2" {

@@ -99,7 +108,7 @@ func TestParseControlCleansText(t *testing.T) {
99	108		}
100	109
101	110		func TestControlLineBetweenFramesLeavesBothIntact(t *testing.T) {
102		-	m, _ := newTest()
	111	+	m, _ := newInteractive()
103	112		m.readFrames(strings.NewReader("one\n\x1b]777;neferbar;{\"type\":\"close\"}\x07\ntwo\n"))
104	113		got, changed, _ := m.Take(nil)
105	114		if !changed \|\| string(got) != "two" {

@@ -114,7 +123,7 @@ func TestControlLineBetweenFramesLeavesBothIntact(t *testing.T) {
114	123		}
115	124
116	125		// The control line alone never becomes a frame.
117		-	m, _ = newTest()
	126	+	m, _ = newInteractive()
118	127		m.readFrames(strings.NewReader("one\n"))
119	128		m.Take(nil)
120	129		m.readFrames(strings.NewReader("\x1b]777;neferbar;{\"type\":\"close\"}\x07\n"))

@@ -124,7 +133,7 @@ func TestControlLineBetweenFramesLeavesBothIntact(t *testing.T) {
124	133		}
125	134
126	135		func TestUnterminatedControlIsAFrame(t *testing.T) {
127		-	m, _ := newTest()
	136	+	m, _ := newInteractive()
128	137		m.readFrames(strings.NewReader("\x1b]777;neferbar;{bad\n"))
129	138		if _, ok := m.TakeControl(); ok {
130	139		t.Fatal("a line without BEL is not a control line")

@@ -136,7 +145,7 @@ func TestUnterminatedControlIsAFrame(t *testing.T) {
136	145		}
137	146
138	147		func TestOversizeControlIsDropped(t *testing.T) {
139		-	m, _ := newTest()
	148	+	m, _ := newInteractive()
140	149		m.readFrames(strings.NewReader("a\n\x1b]777;neferbar;" + strings.Repeat("x", MaxControl) + "\x07\nb\n"))
141	150		if _, ok := m.TakeControl(); ok {
142	151		t.Fatal("an oversize control line must be dropped")

@@ -147,7 +156,7 @@ func TestOversizeControlIsDropped(t *testing.T) {
147	156		}
148	157
149	158		func TestControlQueueDropsWhenFull(t *testing.T) {
150		-	m, wake := newTest()
	159	+	m, wake := newInteractive()
151	160		var in strings.Builder
152	161		for range 20 {
153	162		in.WriteString("\x1b]777;neferbar;{\"type\":\"close\"}\x07\n")

@@ -164,3 +173,35 @@ func TestControlQueueDropsWhenFull(t *testing.T) {
164	173		t.Fatalf("queued %d (want 8), wake %d", n, len(wake))
165	174		}
166	175		}
	176	+
	177	+	func TestControlLinesOfANonInteractiveModuleAreDropped(t *testing.T) {
	178	+	m, wake := newTest()
	179	+	m.readFrames(strings.NewReader("one\n\x1b]777;neferbar;{\"type\":\"close\"}\x07\ntwo\n"))
	180	+	if _, ok := m.TakeControl(); ok {
	181	+	t.Fatal("a non-interactive module queued a control line")
	182	+	}
	183	+	if got, _, _ := m.Take(nil); string(got) != "two" {
	184	+	t.Fatalf("frame = %q, want two (the control line is still not a frame)", got)
	185	+	}
	186	+	if len(wake) != 1 { // from the frames only
	187	+	t.Fatalf("wake = %d", len(wake))
	188	+	}
	189	+	}
	190	+
	191	+	func TestOversizeControlWarnsOncePerRun(t *testing.T) {
	192	+	var logs bytes.Buffer
	193	+	m, _ := newInteractive()
	194	+	m.log = slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
	195	+	big := "\x1b]777;neferbar;" + strings.Repeat("x", MaxControl) + "\x07\n"
	196	+	m.readFrames(strings.NewReader(big + big + big))
	197	+	warns := func() int { return strings.Count(logs.String(), "level=WARN") }
	198	+	if warns() != 1 \|\| strings.Count(logs.String(), "level=DEBUG") != 2 {
	199	+	t.Fatalf("want 1 warning and 2 debug lines:\n%s", logs.String())
	200	+	}
	201	+	// A new run of the script warns again; runOnce resets the flag.
	202	+	m.overLogged = false
	203	+	m.readFrames(strings.NewReader(big))
	204	+	if warns() != 2 {
	205	+	t.Fatalf("a new run must warn again:\n%s", logs.String())
	206	+	}
	207	+	}

 package module
 import (
+	"bytes"
 	"fmt"
+	"log/slog"
 	"strings"
 	"testing"
 )
+// newInteractive is newTest for a module that may send control lines.
+func newInteractive() (*Module, chan struct{}) {
+	m, wake := newTest()
+	m.Interactive = true
+	return m, wake
+}
 func TestParseControlValid(t *testing.T) {
 	c, err := ParseControl([]byte(`{"type":"tooltip","col":2,"width":1,"title":"Steam","body":"line1\nline2"}`))
 	if err != nil || c.Type != ControlTooltip || c.Col != 2 || c.Width != 1 || c.Title != "Steam" || c.Body != "line1\nline2" {
 }
 func TestControlLineBetweenFramesLeavesBothIntact(t *testing.T) {
-	m, _ := newTest()
+	m, _ := newInteractive()
 	m.readFrames(strings.NewReader("one\n\x1b]777;neferbar;{\"type\":\"close\"}\x07\ntwo\n"))
 	got, changed, _ := m.Take(nil)
 	if !changed || string(got) != "two" {
 	}
 	// The control line alone never becomes a frame.
-	m, _ = newTest()
+	m, _ = newInteractive()
 	m.readFrames(strings.NewReader("one\n"))
 	m.Take(nil)
 	m.readFrames(strings.NewReader("\x1b]777;neferbar;{\"type\":\"close\"}\x07\n"))
 }
 func TestUnterminatedControlIsAFrame(t *testing.T) {
-	m, _ := newTest()
+	m, _ := newInteractive()
 	m.readFrames(strings.NewReader("\x1b]777;neferbar;{bad\n"))
 	if _, ok := m.TakeControl(); ok {
 		t.Fatal("a line without BEL is not a control line")
 }
 func TestOversizeControlIsDropped(t *testing.T) {
-	m, _ := newTest()
+	m, _ := newInteractive()
 	m.readFrames(strings.NewReader("a\n\x1b]777;neferbar;" + strings.Repeat("x", MaxControl) + "\x07\nb\n"))
 	if _, ok := m.TakeControl(); ok {
 		t.Fatal("an oversize control line must be dropped")
 }
 func TestControlQueueDropsWhenFull(t *testing.T) {
-	m, wake := newTest()
+	m, wake := newInteractive()
 	var in strings.Builder
 	for range 20 {
 		in.WriteString("\x1b]777;neferbar;{\"type\":\"close\"}\x07\n")
 		t.Fatalf("queued %d (want 8), wake %d", n, len(wake))
 	}
 }
+func TestControlLinesOfANonInteractiveModuleAreDropped(t *testing.T) {
+	m, wake := newTest()
+	m.readFrames(strings.NewReader("one\n\x1b]777;neferbar;{\"type\":\"close\"}\x07\ntwo\n"))
+	if _, ok := m.TakeControl(); ok {
+		t.Fatal("a non-interactive module queued a control line")
+	}
+	if got, _, _ := m.Take(nil); string(got) != "two" {
+		t.Fatalf("frame = %q, want two (the control line is still not a frame)", got)
+	}
+	if len(wake) != 1 { // from the frames only
+		t.Fatalf("wake = %d", len(wake))
+	}
+}
+func TestOversizeControlWarnsOncePerRun(t *testing.T) {
+	var logs bytes.Buffer
+	m, _ := newInteractive()
+	m.log = slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	big := "\x1b]777;neferbar;" + strings.Repeat("x", MaxControl) + "\x07\n"
+	m.readFrames(strings.NewReader(big + big + big))
+	warns := func() int { return strings.Count(logs.String(), "level=WARN") }
+	if warns() != 1 || strings.Count(logs.String(), "level=DEBUG") != 2 {
+		t.Fatalf("want 1 warning and 2 debug lines:\n%s", logs.String())
+	}
+	// A new run of the script warns again; runOnce resets the flag.
+	m.overLogged = false
+	m.readFrames(strings.NewReader(big))
+	if warns() != 2 {
+		t.Fatalf("a new run must warn again:\n%s", logs.String())
+	}
+}

M internal/module/module.go +18 -3


@@ -63,6 +63,10 @@ type Module struct {
63	63		control chan []byte // control lines of the script, see TakeControl
64	64		gen atomic.Uint64 // counts script starts; see Gen
65	65
	66	+	// overLogged: an oversize control line was already logged at Warn in this
	67	+	// run of the script. Touched by runOnce and readFrames, which never overlap.
	68	+	overLogged bool
	69	+
66	70		wake chan<- struct{}
67	71		log *slog.Logger
68	72

@@ -193,6 +197,7 @@ func (m *Module) Run(ctx context.Context) {
193	197
194	198		func (m *Module) runOnce(ctx context.Context) error {
195	199		m.gen.Add(1)
	200	+	m.overLogged = false // readFrames of the previous run has ended
196	201		cmd := exec.CommandContext(ctx, "/bin/sh", "-c", m.Exec)
197	202		cmd.Stderr = &logWriter{log: m.log, name: m.Name}
198	203		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pdeathsig: syscall.SIGTERM}

@@ -284,9 +289,13 @@ func (m *Module) TakeControl() ([]byte, bool) {
284	289		}
285	290		}
286	291
287		-	// queueControl keeps a copy of the JSON of a control line. A full queue drops
288		-	// the line: the bar is not draining it.
	292	+	// queueControl keeps a copy of the JSON of a control line of an interactive
	293	+	// module. A full queue drops the
	294	+	// line: the bar is not draining it.
289	295		func (m *Module) queueControl(json []byte) {
	296	+	if !m.Interactive {
	297	+	return // only interactive modules open popups: do not keep or parse the line
	298	+	}
290	299		select {
291	300		case m.control <- append([]byte(nil), json...):
292	301		m.signal()

@@ -300,7 +309,13 @@ func (m *Module) line(line []byte, over bool) {
300	309		if bytes.HasPrefix(line, []byte(controlPrefix)) {
301	310		switch {
302	311		case over:
303		-	m.log.Warn("module control line too long; dropped", "module", m.Name, "max", MaxControl)
	312	+	// A script can repeat this at will: say it once per run.
	313	+	if !m.overLogged {
	314	+	m.overLogged = true
	315	+	m.log.Warn("module control line too long; dropped (shown once per run)", "module", m.Name, "max", MaxControl)
	316	+	} else {
	317	+	m.log.Debug("module control line too long; dropped", "module", m.Name, "max", MaxControl)
	318	+	}
304	319		return
305	320		case len(line) > 0 && line[len(line)-1] == controlEnd:
306	321		m.queueControl(line[len(controlPrefix) : len(line)-1])

 	control chan []byte   // control lines of the script, see TakeControl
 	gen     atomic.Uint64 // counts script starts; see Gen
+	// overLogged: an oversize control line was already logged at Warn in this
+	// run of the script. Touched by runOnce and readFrames, which never overlap.
+	overLogged bool
 	wake chan<- struct{}
 	log  *slog.Logger
 func (m *Module) runOnce(ctx context.Context) error {
 	m.gen.Add(1)
+	m.overLogged = false // readFrames of the previous run has ended
 	cmd := exec.CommandContext(ctx, "/bin/sh", "-c", m.Exec)
 	cmd.Stderr = &logWriter{log: m.log, name: m.Name}
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pdeathsig: syscall.SIGTERM}
 	}
 }
-// queueControl keeps a copy of the JSON of a control line. A full queue drops
+// queueControl keeps a copy of the JSON of a control line of an interactive
-// the line: the bar is not draining it.
+// module. A full queue drops the
+// line: the bar is not draining it.
 func (m *Module) queueControl(json []byte) {
+	if !m.Interactive {
+		return // only interactive modules open popups: do not keep or parse the line
+	}
 	select {
 	case m.control <- append([]byte(nil), json...):
 		m.signal()
 	if bytes.HasPrefix(line, []byte(controlPrefix)) {
 		switch {
 		case over:
-			m.log.Warn("module control line too long; dropped", "module", m.Name, "max", MaxControl)
+			// A script can repeat this at will: say it once per run.
+			if !m.overLogged {
+				m.overLogged = true
+				m.log.Warn("module control line too long; dropped (shown once per run)", "module", m.Name, "max", MaxControl)
+			} else {
+				m.log.Debug("module control line too long; dropped", "module", m.Name, "max", MaxControl)
+			}
 			return
 		case len(line) > 0 && line[len(line)-1] == controlEnd:
 			m.queueControl(line[len(controlPrefix) : len(line)-1])