From f89dee54490da82753e2fae293b4314cde1b06d3 Mon Sep 17 00:00:00 2001 From: Geno Roupsky <185580+groupsky@users.noreply.github.com> Date: Tue, 17 Nov 2026 10:05:20 +0200 Subject: [PATCH] fix: --ask-again closes a lost open question, and the listener reports a bad outbox file `pullgate status NAME --ask-again` now also removes an open question for the last tip from root's state, then asks the listener to close its message. The next run asks again with a new question ID and code. An approval for the old code finds no question and does nothing. The listener sends one notice per round when it removes an outbox file that it cannot read or parse. It names the instance and the command `pullgate status NAME --ask-again`, and shows no part of the file. When the file cannot be removed, it sends no notice. Fixes #22 Co-Authored-By: Claude Opus 5.5 --- DESIGN.md | 16 +++- README.md | 5 +- THREAT-MODEL.md | 7 +- cmd/pullgate/main.go | 2 + internal/gate/gate_test.go | 128 +++++++++++++++++++++++++++++ internal/gate/status.go | 26 +++++- internal/listener/listener.go | 26 +++++- internal/listener/listener_test.go | 58 +++++++++++++ 8 files changed, 260 insertions(+), 8 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index 0afc955..f4bf9ab 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -310,7 +310,8 @@ used again. - tip is the held SHA, or was asked before and the question expired or was skipped, or its check failed, or it was refused, or it failed `max_failed_tries` times: nothing to do. `pullgate status NAME - --ask-again` clears this mark. + --ask-again` clears this mark, and also closes an open question for + the tip (section 13). - tip is not a descendant of the applied SHA (an older commit, a force push, a rewritten branch) and `allow_older` is false: refuse. Send one notice for this SHA and mark it refused. When `allow_older` is true, @@ -350,7 +351,11 @@ name order and skips names that start with `.`. Kinds: - `reply`: `question`, `text`: a reply to that question, or a new message when the listener does not know the question. -A file the listener cannot parse is removed and logged. If Telegram refuses +A file the listener cannot read or parse is removed and logged. The owner +also gets one notice per round for such files: "an outbox message of +instance NAME could not be read and was removed", with the command +`pullgate status NAME --ask-again`. The notice shows no part of the file, +because it may be a question that the owner never saw. If Telegram refuses a message, the listener tries again on the next round, and drops it after one day with a log line. @@ -649,7 +654,12 @@ closed after a cut. the held SHA, the pause file and an apply in progress. Flags: - `--ask-again`: clear the marks of the last fetched tip (expired, skipped, - check failed, refused, failed, held), so the next run asks again; + check failed, refused, failed, held), so the next run asks again. If a + question for the tip is open (for example its message was lost), root + removes it from its state, then asks the listener to close its message. + The next run asks again with a new question ID and a new code. An + approval for the old code finds no question and does nothing, even one + that the listener wrote before the close; - `--pause`: write the pause file; - `--resume`: remove the pause file and clear an apply in progress. diff --git a/README.md b/README.md index 69a0d42..46e89ed 100644 --- a/README.md +++ b/README.md @@ -195,7 +195,10 @@ sections 5 and 11. `pullgate status NAME` shows the state. As root: `pullgate status NAME --pause` stops the instance, `pullgate status NAME --resume` starts it again, and -`pullgate status NAME --ask-again` asks about the tip again. +`pullgate status NAME --ask-again` asks about the tip again. If a question +for the tip is still open (for example its Telegram message was lost), it +closes that question too: the next run sends a new question, and the Apply +button of the old one no longer works. ## Example 1: a config file and a service reload diff --git a/THREAT-MODEL.md b/THREAT-MODEL.md index 6798375..ec0dcc1 100644 --- a/THREAT-MODEL.md +++ b/THREAT-MODEL.md @@ -254,7 +254,12 @@ tap on a closed or expired question, writes nothing. The listener also keeps the last 200 update IDs it handled and ignores an update with one of them, a tap or a `/check` alike. Root removes a question from its state before it acts, so a replayed approval finds no question. -Root checks the time limit itself. A tap on a superseded question that the +Root checks the time limit itself. `--ask-again` removes an open question +for the tip from root's state (its message may be lost), so a tap on it, +even one already written, finds no question; the new question has a new +code. A question lost in the outbox is not silent: the listener tells the +owner when it removes an outbox file that it cannot read, and names the +instance, but shows no part of the file. A tap on a superseded question that the listener took before it handled the close still applies the old SHA (rule 2); the forward-only check still holds then. diff --git a/cmd/pullgate/main.go b/cmd/pullgate/main.go index 02f01c3..c4e4730 100644 --- a/cmd/pullgate/main.go +++ b/cmd/pullgate/main.go @@ -29,6 +29,8 @@ commands: run NAME fetch, check, and ask (the timer runs it, as root) apply NAME act on approvals (the path unit runs it, as root) status NAME [--ask-again] [--pause] [--resume] + --ask-again: ask about the last tip again; it also closes + an open question for it, so the next run sends a new one listen [--config FILE] the Telegram listener (its own user) version` diff --git a/internal/gate/gate_test.go b/internal/gate/gate_test.go index bd9dcc6..f8b16ff 100644 --- a/internal/gate/gate_test.go +++ b/internal/gate/gate_test.go @@ -229,6 +229,134 @@ func TestSkip(t *testing.T) { _ = a } +// TestAskAgainReplacesALostQuestion: the message of an open question was +// lost (code6x/pullgate#22). --ask-again closes it, the next run asks +// again with a new question, and an approval for the old code does not +// apply. +func TestAskAgainReplacesALostQuestion(t *testing.T) { + f := newFixture(t, ``, "") + tip := f.commit("first", "one", nil) + if r := f.run(); r != Asked { + t.Fatalf("run: %s", r) + } + old := f.ask() // read and dropped: as if the listener lost it + if r := f.run(); r != Nothing { + t.Fatalf("an open question is not asked again by a plain run: %s", r) + } + var out strings.Builder + if err := f.env.Status(&out, StatusFlags{AskAgain: true}); err != nil { + t.Fatal(err) + } + if !strings.Contains(out.String(), "question: none") { + t.Fatalf("--ask-again must close the open question:\n%s", out.String()) + } + ms := f.outbox() + if len(ms) != 1 || ms[0].Kind != spool.KindEdit || ms[0].Question != old.Question || !strings.Contains(ms[0].Text, "closed") { + t.Fatalf("--ask-again must close the old message: %+v", ms) + } + if r := f.run(); r != Asked { + t.Fatalf("the run after --ask-again must ask: %s", r) + } + nq := f.ask() + if nq.Question == old.Question || nq.Code == old.Code { + t.Fatalf("the new question must have a new ID and code: old %d, new %d", old.Question, nq.Question) + } + if q := f.state().Open(); q == nil || q.ID != nq.Question || q.SHA != tip { + t.Fatalf("the new question must be open: %+v", q) + } + // An Apply for the old question applies nothing. + f.tap(old.Code, "apply") + if r := f.apply(); r == Applied || f.state().Applied != "" { + t.Fatalf("an Apply for the closed question must not apply: %s", r) + } + if q := f.state().Open(); q == nil || q.ID != nq.Question { + t.Fatal("the new question must stay open") + } + // The new one still works. + f.tap(nq.Code, "apply") + if r := f.apply(); r != Applied || f.state().Applied != tip { + t.Fatalf("an Apply for the new question applies: %s", r) + } +} + +// TestAskAgainDropsAnApprovalWrittenBefore: a tap on the lost question +// that reached the inbox before --ask-again finds no question. +func TestAskAgainDropsAnApprovalWrittenBefore(t *testing.T) { + f := newFixture(t, ``, "") + f.commit("first", "one", nil) + f.run() + old := f.ask() + f.tap(old.Code, "apply") + if err := f.env.Status(new(strings.Builder), StatusFlags{AskAgain: true}); err != nil { + t.Fatal(err) + } + if r := f.apply(); r == Applied || f.state().Applied != "" { + t.Fatalf("an approval written before --ask-again must not apply: %s", r) + } + if r := f.run(); r != Asked { + t.Fatalf("the next run asks again: %s", r) + } +} + +// TestAskAgainInAutoMode: an auto question for the tip is removed too, with +// no edit (it has no message), and the old auto approval applies nothing. +func TestAskAgainInAutoMode(t *testing.T) { + f := newFixture(t, `mode = "auto"`, "") + tip := f.commit("first", "one", nil) + if r := f.run(); r != AutoQueued { + t.Fatalf("run: %s", r) + } + autoCode := func() string { + b, _ := os.ReadFile(f.env.Dir.AutoFile()) + return strings.TrimSpace(string(b)) + } + oldAuto := autoCode() + if oldAuto == "" { + t.Fatal("no auto approval file") + } + if err := f.env.Status(new(strings.Builder), StatusFlags{AskAgain: true}); err != nil { + t.Fatal(err) + } + if f.state().Open() != nil { + t.Fatal("--ask-again must remove the open auto question") + } + if ms := f.outbox(); len(ms) != 0 { + t.Fatalf("an auto question has no message to edit: %+v", ms) + } + if r := f.apply(); r == Applied || f.state().Applied != "" { + t.Fatalf("the old auto approval must not apply: %s", r) + } + if r := f.run(); r != AutoQueued || autoCode() == oldAuto || autoCode() == "" { + t.Fatalf("the next run queues a new auto approval: %s", r) + } + if r := f.apply(); r != Applied || f.state().Applied != tip { + t.Fatalf("the new auto approval applies: %s", r) + } +} + +// TestAskAgainKeepsAnOpenQuestionForAnotherSHA: --ask-again acts only on +// the tip; an open question for another SHA is left alone. +func TestAskAgainKeepsAnOpenQuestionForAnotherSHA(t *testing.T) { + f := newFixture(t, ``, "") + f.commit("first", "one", nil) + f.run() + q := f.ask() + st := f.state() + st.LastTip = strings.Repeat("b", 40) + if err := f.env.Dir.Save(st); err != nil { + t.Fatal(err) + } + if err := f.env.Status(new(strings.Builder), StatusFlags{AskAgain: true}); err != nil { + t.Fatal(err) + } + if o := f.state().Open(); o == nil || o.ID != q.Question { + t.Fatal("an open question for another SHA must stay open") + } + if ms := f.outbox(); len(ms) != 0 { + t.Fatalf("no edit for a question that stays: %+v", ms) + } +} + func TestExpiredApprovalIsIgnored(t *testing.T) { f := newFixture(t, ``, "[limits]\napproval_ttl = \"1h\"\n") f.commit("first", "one", nil) diff --git a/internal/gate/status.go b/internal/gate/status.go index b8c8bf5..458aed2 100644 --- a/internal/gate/status.go +++ b/internal/gate/status.go @@ -36,6 +36,7 @@ func (e *Env) Status(w io.Writer, f StatusFlags) error { return err } changed := false + var closed *state.Question if f.Resume { if err := e.Dir.Resume(); err != nil { return err @@ -50,6 +51,7 @@ func (e *Env) Status(w io.Writer, f StatusFlags) error { if st.Held == st.LastTip { st.Held = "" } + closed = forgetOpen(st, st.LastTip) changed = true } if changed { @@ -57,6 +59,12 @@ func (e *Env) Status(w io.Writer, f StatusFlags) error { return err } } + if closed != nil && !closed.Auto { + // After the save: the listener forgets the code only when root + // has forgotten it too. + e.edit(closed.ID, "This question for "+code(closed.SHA)+" is closed: the owner ran --ask-again. The next run asks again.") + _, _ = fmt.Fprintf(w, "The open question %d for %s is closed. The next run asks again.\n", closed.ID, closed.SHA) + } show := func(k, v string) { _, _ = fmt.Fprintf(w, "%-12s %s\n", k+":", v) } show("instance", e.Cfg.Name) show("mode", e.Cfg.Mode) @@ -85,11 +93,25 @@ func (e *Env) Status(w io.Writer, f StatusFlags) error { return nil } +// forgetOpen removes the open question for sha from the state and returns +// it, so that the next run asks again with a new question and a new code. +// Its message may never have reached the owner (a lost outbox file). +// Unlike a superseded question, it does not stay in the list: an approval +// for its code, even one written before this, finds no question and is +// ignored (fail closed). +func forgetOpen(st *state.State, sha string) *state.Question { + for i := range st.Questions { + if q := st.Questions[i]; q.Open && q.SHA == sha { + st.Remove(i) + return &q + } + } + return nil +} + func orNone(s string) string { if s == "" { return "none" } return s } - -var _ = state.MarkAsked diff --git a/internal/listener/listener.go b/internal/listener/listener.go index 5fe01a0..5b85255 100644 --- a/internal/listener/listener.go +++ b/internal/listener/listener.go @@ -195,10 +195,23 @@ instances: l.Log.Warn("read the outbox", "instance", inst, "err", err) continue } + told := false for _, f := range files { if f.Err != nil { + if err := d.Done(f.Name); err != nil { + // Not removed: say nothing to the owner, or every + // round would send the same notice. + l.Log.Warn("bad outbox file, could not remove it", "instance", inst, "file", f.Name, "err", f.Err, "remove_err", err) + continue + } l.Log.Warn("bad outbox file, removed", "instance", inst, "file", f.Name, "err", f.Err) - _ = d.Done(f.Name) + if !told { + // The text cannot be read, but the owner must know that + // a message (maybe a question) is lost. One notice per + // pass is enough, also for many bad files. + told = true + l.badOutboxNotice(ctx, inst) + } continue } err := l.send(ctx, inst, f.Message) @@ -226,6 +239,17 @@ instances: } } +// badOutboxNotice tells the owner that an outbox file of inst could not be +// read and was removed. It shows no part of the file. A failed send is +// only logged: the file is gone either way. +func (l *Listener) badOutboxNotice(ctx context.Context, inst string) { + name := html.EscapeString(inst) + text := "pullgate: an outbox message of instance " + name + " could not be read and was removed. It may have been a question. To ask again, run as root: pullgate status " + name + " --ask-again" + if _, err := l.TG.SendMessage(ctx, l.Cfg.ChatID, text, nil, 0); err != nil { + l.Log.Warn("send the notice about a bad outbox file", "instance", inst, "err", err) + } +} + func (l *Listener) send(ctx context.Context, inst string, m spool.Message) error { chat := l.Cfg.ChatID switch m.Kind { diff --git a/internal/listener/listener_test.go b/internal/listener/listener_test.go index 60c85bb..715797b 100644 --- a/internal/listener/listener_test.go +++ b/internal/listener/listener_test.go @@ -198,6 +198,64 @@ func TestReplyAndNotice(t *testing.T) { } } +// TestBadOutboxFileTellsTheOwner: an outbox file that the listener cannot +// read is removed, and the owner gets one notice that names the instance +// and the command to ask again (code6x/pullgate#22). +func TestBadOutboxFileTellsTheOwner(t *testing.T) { + if os.Geteuid() == 0 { + t.Skip("root can read a file with mode 0") + } + f := newL(t) + out := f.d.Outbox() + if err := os.WriteFile(filepath.Join(out, "0-a-unreadable"), []byte(`{"kind":"notice","text":"secret text"}`), 0o000); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(out, "0-b-broken"), []byte("not json"), 0o600); err != nil { + t.Fatal(err) + } + _ = f.d.Send(os.Getegid(), spool.Message{Kind: spool.KindNotice, Text: "good notice"}) + f.l.Outbox(context.Background()) + ms := f.tg.Messages() + if len(ms) != 2 { + t.Fatalf("want one notice for the bad files and the good message, got %+v", ms) + } + n := ms[0].Text + if !strings.Contains(n, ""+inst+"") || !strings.Contains(n, "pullgate status "+inst+" --ask-again") || !strings.Contains(n, "removed") { + t.Fatalf("the notice must name the instance and the command: %q", n) + } + if strings.Contains(n, "secret") || strings.Contains(n, "json") || strings.Contains(n, "0-a-unreadable") { + t.Fatalf("the notice must not show the file: %q", n) + } + if ms[1].Text != "good notice" { + t.Fatalf("the good message must still be sent: %+v", ms[1]) + } + if left, _ := os.ReadDir(out); len(left) != 0 { + t.Fatalf("the bad files must be removed: %v", left) + } + // A pass with no bad file sends no notice. + f.l.Outbox(context.Background()) + if len(f.tg.Messages()) != 2 { + t.Fatal("no new notice without a bad file") + } +} + +// TestBadOutboxEntryThatStaysSendsNoNotice: an outbox entry that cannot +// be removed (a directory with a file in it) gets no "removed" notice, so +// the chat is not filled with one notice per round. +func TestBadOutboxEntryThatStaysSendsNoNotice(t *testing.T) { + f := newL(t) + dir := filepath.Join(f.d.Outbox(), "0-dir") + if err := os.MkdirAll(filepath.Join(dir, "x"), 0o700); err != nil { + t.Fatal(err) + } + for range 3 { + f.l.Outbox(context.Background()) + } + if ms := f.tg.Messages(); len(ms) != 0 { + t.Fatalf("no notice for an entry that was not removed: %+v", ms) + } +} + func TestTokenNeverInErrors(t *testing.T) { c := telegram.New("http://127.0.0.1:1", token) _, err := c.SendMessage(context.Background(), 1, "x", nil, 0)