From 952fada19cc1df3fc5b5d3a9723b8d842e7a3569 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 15:12:51 +0100 Subject: [PATCH] refactor: move daemon wiring into internal/app and test it end to end - Add app.Start and App.Close, main only parses flags and waits for signals - Add end-to-end test: API creates a list, LMTP posts, a fake relay receives VERP copies - Cover disabled API, bad database, busy port and idempotent Close - Fix a shutdown race: Close before Serve left the LMTP server blocked --- internal/app/app.go | 118 ++++++++++++++++++++++ internal/app/app_test.go | 212 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 330 insertions(+) create mode 100644 internal/app/app.go create mode 100644 internal/app/app_test.go diff --git a/internal/app/app.go b/internal/app/app.go new file mode 100644 index 0000000..7c40b54 --- /dev/null +++ b/internal/app/app.go @@ -0,0 +1,118 @@ +// Package app wires the store, router, LMTP server and REST API together. +package app + +import ( + "context" + "errors" + "fmt" + "log" + "net" + "net/http" + "os" + "sync" + "time" + + "github.com/emersion/go-smtp" + + "codeberg.org/squidd/parsimony/internal/api" + "codeberg.org/squidd/parsimony/internal/config" + "codeberg.org/squidd/parsimony/internal/ingest" + "codeberg.org/squidd/parsimony/internal/outbound" + "codeberg.org/squidd/parsimony/internal/router" + "codeberg.org/squidd/parsimony/internal/store" +) + +// App is a running daemon. +type App struct { + // LMTPAddr and APIAddr are the addresses actually bound. + // APIAddr is empty when the API is disabled. + LMTPAddr string + APIAddr string + + store *store.Store + lmtp *smtp.Server + lns []net.Listener // closed by Close so Serve returns even if Close wins the race with it + web *http.Server + wg sync.WaitGroup + once sync.Once +} + +// releaser lets the API approve held messages through the router. +type releaser struct { + rt *router.Router + out outbound.Sender +} + +func (r releaser) Release(ctx context.Context, id int64) error { return r.rt.Release(ctx, r.out, id) } + +// Start opens the database and begins serving. The REST API runs only when +// apiToken is not empty. +func Start(cfg config.Config, apiToken string) (*App, error) { + st, err := store.Open(cfg.DB) + if err != nil { + return nil, fmt.Errorf("store: %w", err) + } + a := &App{store: st} + + rt := router.New(st) + rt.BaseURL = cfg.BaseURL + relay := &outbound.SMTPRelay{Addr: cfg.Relay.Addr} + a.lmtp = ingest.NewServer(rt, relay) + + if cfg.LMTP.Network == "unix" { + os.Remove(cfg.LMTP.Addr) + } + lmtpLn, err := net.Listen(cfg.LMTP.Network, cfg.LMTP.Addr) + if err != nil { + st.Close() + return nil, fmt.Errorf("listen lmtp: %w", err) + } + a.LMTPAddr = lmtpLn.Addr().String() + a.lns = append(a.lns, lmtpLn) + + var apiLn net.Listener + if apiToken != "" { + apiLn, err = net.Listen("tcp", cfg.API.Listen) + if err != nil { + lmtpLn.Close() + st.Close() + return nil, fmt.Errorf("listen api: %w", err) + } + a.APIAddr = apiLn.Addr().String() + a.lns = append(a.lns, apiLn) + a.web = &http.Server{Handler: api.New(st, apiToken, releaser{rt, relay}), ReadHeaderTimeout: 10 * time.Second} + } + + a.wg.Add(1) + go func() { + defer a.wg.Done() + if err := a.lmtp.Serve(lmtpLn); err != nil && !errors.Is(err, smtp.ErrServerClosed) { + log.Printf("lmtp: %v", err) + } + }() + if a.web != nil { + a.wg.Add(1) + go func() { + defer a.wg.Done() + if err := a.web.Serve(apiLn); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Printf("api: %v", err) + } + }() + } + return a, nil +} + +// Close stops the servers and closes the database. It is safe to call twice. +func (a *App) Close() { + a.once.Do(func() { + for _, ln := range a.lns { + ln.Close() + } + a.lmtp.Close() + if a.web != nil { + a.web.Close() + } + a.wg.Wait() + a.store.Close() + }) +} diff --git a/internal/app/app_test.go b/internal/app/app_test.go new file mode 100644 index 0000000..a984a65 --- /dev/null +++ b/internal/app/app_test.go @@ -0,0 +1,212 @@ +package app + +import ( + "io" + "net" + "net/http" + "strings" + "sync" + "testing" + "time" + + "github.com/emersion/go-smtp" + + "codeberg.org/squidd/parsimony/internal/config" +) + +// sink is a fake SMTP relay that records what it receives. +type sink struct { + mu sync.Mutex + msgs []sunk +} + +type sunk struct { + from string + to []string + data string +} + +func (s *sink) NewSession(*smtp.Conn) (smtp.Session, error) { return &sinkSession{s: s}, nil } + +type sinkSession struct { + s *sink + from string + to []string +} + +func (x *sinkSession) Reset() { x.from, x.to = "", nil } +func (x *sinkSession) Logout() error { return nil } +func (x *sinkSession) Mail(f string, _ *smtp.MailOptions) error { + x.from = f + return nil +} +func (x *sinkSession) Rcpt(t string, _ *smtp.RcptOptions) error { + x.to = append(x.to, t) + return nil +} +func (x *sinkSession) Data(r io.Reader) error { + b, _ := io.ReadAll(r) + x.s.mu.Lock() + x.s.msgs = append(x.s.msgs, sunk{x.from, x.to, string(b)}) + x.s.mu.Unlock() + return nil +} + +func (s *sink) count() int { + s.mu.Lock() + defer s.mu.Unlock() + return len(s.msgs) +} + +func startSink(t *testing.T) (string, *sink) { + t.Helper() + sk := &sink{} + srv := smtp.NewServer(sk) + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + go srv.Serve(ln) + t.Cleanup(func() { srv.Close() }) + return ln.Addr().String(), sk +} + +func testConfig(t *testing.T, relay string) config.Config { + t.Helper() + var c config.Config + c.DB = t.TempDir() + "/p.db" + c.LMTP.Network = "tcp" + c.LMTP.Addr = "127.0.0.1:0" + c.Relay.Addr = relay + c.API.Listen = "127.0.0.1:0" + return c +} + +func call(t *testing.T, a *App, method, path, body, token string) int { + t.Helper() + req, _ := http.NewRequest(method, "http://"+a.APIAddr+path, strings.NewReader(body)) + if token != "" { + req.Header.Set("Authorization", "Bearer "+token) + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + resp.Body.Close() + return resp.StatusCode +} + +func lmtpSend(t *testing.T, addr, from, rcpt, msg string) error { + t.Helper() + conn, err := net.Dial("tcp", addr) + if err != nil { + t.Fatal(err) + } + c := smtp.NewClientLMTP(conn) + defer c.Close() + if err := c.Hello("localhost"); err != nil { + t.Fatal(err) + } + if err := c.Mail(from, nil); err != nil { + t.Fatal(err) + } + if err := c.Rcpt(rcpt, nil); err != nil { + t.Fatal(err) + } + w, err := c.Data() + if err != nil { + t.Fatal(err) + } + w.Write([]byte(msg)) + _, err = w.CloseWithLMTPResponse() + return err +} + +func TestEndToEnd(t *testing.T) { + relayAddr, relay := startSink(t) + a, err := Start(testConfig(t, relayAddr), "tok") + if err != nil { + t.Fatalf("start: %v", err) + } + t.Cleanup(func() { a.Close() }) + + if code := call(t, a, "GET", "/api/v1/health", "", ""); code != 200 { + t.Fatalf("health = %d", code) + } + if code := call(t, a, "GET", "/api/v1/lists", "", ""); code != 401 { + t.Fatalf("unauthenticated = %d", code) + } + if code := call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok"); code != 201 { + t.Fatalf("create list = %d", code) + } + for _, m := range []string{"alice@example.com", "bob@example.com"} { + if code := call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"`+m+`"}`, "tok"); code != 201 { + t.Fatalf("add %s = %d", m, code) + } + } + + msg := "From: Alice \r\nSubject: hello\r\n\r\nbody\r\n" + if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { + t.Fatalf("lmtp: %v", err) + } + if relay.count() != 2 { + t.Fatalf("relay got %d messages, want 2", relay.count()) + } + got := relay.msgs[0] + if !strings.Contains(got.data, "List-Id: Dev ") || !strings.HasPrefix(got.from, "dev+bounce-") { + t.Fatalf("unexpected relayed mail: %+v", got) + } + if err := lmtpSend(t, a.LMTPAddr, "mallory@evil.com", "dev@example.org", msg); err == nil { + t.Fatal("non-member must be rejected") + } + if relay.count() != 2 { + t.Fatal("rejected mail must not be relayed") + } +} + +func TestStartWithoutTokenDisablesAPI(t *testing.T) { + relayAddr, _ := startSink(t) + a, err := Start(testConfig(t, relayAddr), "") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { a.Close() }) + if a.APIAddr != "" { + t.Fatalf("API must be disabled, listening on %s", a.APIAddr) + } + if conn, err := net.DialTimeout("tcp", a.LMTPAddr, time.Second); err != nil { + t.Fatalf("LMTP must still run: %v", err) + } else { + conn.Close() + } +} + +func TestStartFailsOnBadDatabase(t *testing.T) { + c := testConfig(t, "127.0.0.1:1") + c.DB = "/nonexistent-dir/x/p.db" + if _, err := Start(c, ""); err == nil { + t.Fatal("want error") + } +} + +func TestStartFailsWhenPortIsBusy(t *testing.T) { + ln, _ := net.Listen("tcp", "127.0.0.1:0") + defer ln.Close() + c := testConfig(t, "127.0.0.1:1") + c.LMTP.Addr = ln.Addr().String() + if _, err := Start(c, ""); err == nil { + t.Fatal("want error") + } +} + +func TestCloseIsIdempotentAndStopsListeners(t *testing.T) { + relayAddr, _ := startSink(t) + a, _ := Start(testConfig(t, relayAddr), "tok") + addr := a.LMTPAddr + a.Close() + a.Close() + if c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond); err == nil { + c.Close() + t.Fatal("LMTP still accepting after Close") + } +}