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
This commit is contained in:
tgiachi 2026-11-09 15:12:51 +01:00
commit 952fada19c
2 changed files with 330 additions and 0 deletions

118
internal/app/app.go Normal file
View file

@ -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()
})
}

212
internal/app/app_test.go Normal file
View file

@ -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 <alice@example.com>\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 <dev.example.org>") || !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")
}
}