sneak/chat
1
0
Fork 0
Code Issues 15 Pull Requests Actions Packages Projects Releases Wiki Activity

fix: address all PR #10 review findings
All checks were successful
check / check (push) Successful in 2m19s
Details

Browse Source 
Security:
- Add channel membership check before PRIVMSG (prevents non-members from sending)
- Add membership check on history endpoint (channels require membership, DMs scoped to own nick)
- Enforce MaxBytesReader on all POST request bodies
- Fix rand.Read error being silently ignored in token generation

Data integrity:
- Fix TOCTOU race in GetOrCreateChannel using INSERT OR IGNORE + SELECT

Build:
- Add CGO_ENABLED=0 to golangci-lint install in Dockerfile (fixes alpine build)

Linting:
- Strict .golangci.yml: only wsl disabled (deprecated in v2)
- Re-enable exhaustruct, depguard, godot, wrapcheck, varnamelen
- Fix linters-settings -> linters.settings for v2 config format
- Fix ALL lint findings in actual code (no linter config weakening)
- Wrap all external package errors (wrapcheck)
- Fill struct fields or add targeted nolint:exhaustruct where appropriate
- Rename short variables (ts->timestamp, n->bufIndex, etc.)
- Add depguard deny policy for io/ioutil and math/rand
- Exclude G704 (SSRF) in gosec config (CLI client takes user-configured URLs)

Tests:
- Add security tests (TestNonMemberCannotSend, TestHistoryNonMember)
- Split TestInsertAndPollMessages for reduced complexity
- Fix parallel test safety (viper global state prevents parallelism)
- Use t.Context() instead of context.Background() in tests

Docker build verified passing locally.
This commit is contained in:
clawbot 2026-02-26 21:21:49 -08:00
parent 4b4a337a88
commit a57a73e94e
22 changed files with 2650 additions and 1903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
.golangci.yml
View File

@ -7,24 +7,28 @@ run:
linters:
default: all
disable:
# Genuinely incompatible with project patterns
- exhaustruct # Requires all struct fields
- depguard # Dependency allow/block lists
- godot # Requires comments to end with periods
- wsl # Deprecated, replaced by wsl_v5
- wrapcheck # Too verbose for internal packages
- varnamelen # Short names like db, id are idiomatic Go
linters-settings:
lll:
line-length: 88
funlen:
lines: 80
statements: 50
cyclop:
max-complexity: 15
dupl:
threshold: 100
- wsl # Deprecated in v2, replaced by wsl_v5
settings:
lll:
line-length: 88
funlen:
lines: 80
statements: 50
cyclop:
max-complexity: 15
dupl:
threshold: 100
gosec:
excludes:
- G704
depguard:
rules:
all:
deny:
- pkg: "io/ioutil"
desc: "Deprecated; use io and os packages."
- pkg: "math/rand$"
desc: "Use crypto/rand for security-sensitive code."
issues:
exclude-use-default: false

2
Dockerfile
View File

@ -4,7 +4,7 @@ WORKDIR /src
RUN apk add --no-cache git build-base make
# golangci-lint v2.1.6 (eabc2638a66d), 2026-02-26
RUN go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638a66daf5bb6c6fb052a32fa3ef7b6600d
RUN CGO_ENABLED=0 go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638a66daf5bb6c6fb052a32fa3ef7b6600d
COPY go.mod go.sum ./
RUN go mod download

273
cmd/chat-cli/api/client.go
View File

@ -1,3 +1,4 @@
// Package chatapi provides a client for the chat server API.
package chatapi
import (
@ -31,17 +32,19 @@ type Client struct {
// NewClient creates a new API client.
func NewClient(baseURL string) *Client {
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{Timeout: httpTimeout},
return &Client{ //nolint:exhaustruct // Token set after CreateSession
BaseURL: baseURL,
HTTPClient: &http.Client{ //nolint:exhaustruct // defaults fine
Timeout: httpTimeout,
},
}
}
// CreateSession creates a new session on the server.
func (c *Client) CreateSession(
func (client *Client) CreateSession(
nick string,
) (*SessionResponse, error) {
data, err := c.do(
data, err := client.do(
http.MethodPost,
"/api/v1/session",
&SessionRequest{Nick: nick},
@ -57,14 +60,14 @@ func (c *Client) CreateSession(
return nil, fmt.Errorf("decode session: %w", err)
}
c.Token = resp.Token
client.Token = resp.Token
return &resp, nil
}
// GetState returns the current user state.
func (c *Client) GetState() (*StateResponse, error) {
data, err := c.do(
func (client *Client) GetState() (*StateResponse, error) {
data, err := client.do(
http.MethodGet, "/api/v1/state", nil,
)
if err != nil {
@ -82,8 +85,8 @@ func (c *Client) GetState() (*StateResponse, error) {
}
// SendMessage sends a message (any IRC command).
func (c *Client) SendMessage(msg *Message) error {
_, err := c.do(
func (client *Client) SendMessage(msg *Message) error {
_, err := client.do(
http.MethodPost, "/api/v1/messages", msg,
)
@ -91,123 +94,16 @@ func (c *Client) SendMessage(msg *Message) error {
}
// PollMessages long-polls for new messages.
func (c *Client) PollMessages(
func (client *Client) PollMessages(
afterID int64,
timeout int,
) (*PollResult, error) {
client := &http.Client{
pollClient := &http.Client{ //nolint:exhaustruct // defaults fine
Timeout: time.Duration(
timeout+pollExtraTime,
) * time.Second,
}
path := c.buildPollPath(afterID, timeout)
req, err := http.NewRequestWithContext(
context.Background(),
http.MethodGet,
c.BaseURL+path,
nil,
)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.Token)
resp, err := client.Do(req) //nolint:gosec // URL is from configured BaseURL, not user input
if err != nil {
return nil, err
}
defer func() { _ = resp.Body.Close() }()
return c.decodePollResponse(resp)
}
// JoinChannel joins a channel.
func (c *Client) JoinChannel(channel string) error {
return c.SendMessage(
&Message{Command: "JOIN", To: channel},
)
}
// PartChannel leaves a channel.
func (c *Client) PartChannel(channel string) error {
return c.SendMessage(
&Message{Command: "PART", To: channel},
)
}
// ListChannels returns all channels on the server.
func (c *Client) ListChannels() ([]Channel, error) {
data, err := c.do(
http.MethodGet, "/api/v1/channels", nil,
)
if err != nil {
return nil, err
}
var channels []Channel
err = json.Unmarshal(data, &channels)
if err != nil {
return nil, err
}
return channels, nil
}
// GetMembers returns members of a channel.
func (c *Client) GetMembers(
channel string,
) ([]string, error) {
name := strings.TrimPrefix(channel, "#")
data, err := c.do(
http.MethodGet,
"/api/v1/channels/"+url.PathEscape(name)+
"/members",
nil,
)
if err != nil {
return nil, err
}
var members []string
err = json.Unmarshal(data, &members)
if err != nil {
return nil, fmt.Errorf(
"unexpected members format: %w", err,
)
}
return members, nil
}
// GetServerInfo returns server info.
func (c *Client) GetServerInfo() (*ServerInfo, error) {
data, err := c.do(
http.MethodGet, "/api/v1/server", nil,
)
if err != nil {
return nil, err
}
var info ServerInfo
err = json.Unmarshal(data, &info)
if err != nil {
return nil, err
}
return &info, nil
}
func (c *Client) buildPollPath(
afterID int64, timeout int,
) string {
params := url.Values{}
if afterID > 0 {
params.Set(
@ -218,15 +114,32 @@ func (c *Client) buildPollPath(
params.Set("timeout", strconv.Itoa(timeout))
return "/api/v1/messages?" + params.Encode()
}
path := "/api/v1/messages?" + params.Encode()
request, err := http.NewRequestWithContext(
context.Background(),
http.MethodGet,
client.BaseURL+path,
nil,
)
if err != nil {
return nil, fmt.Errorf("new request: %w", err)
}
request.Header.Set(
"Authorization", "Bearer "+client.Token,
)
resp, err := pollClient.Do(request)
if err != nil {
return nil, fmt.Errorf("poll request: %w", err)
}
defer func() { _ = resp.Body.Close() }()
func (c *Client) decodePollResponse(
resp *http.Response,
) (*PollResult, error) {
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
return nil, fmt.Errorf("read poll body: %w", err)
}
if resp.StatusCode >= httpErrThreshold {
@ -251,7 +164,99 @@ func (c *Client) decodePollResponse(
}, nil
}
func (c *Client) do(
// JoinChannel joins a channel.
func (client *Client) JoinChannel(channel string) error {
return client.SendMessage(
&Message{ //nolint:exhaustruct // only command+to needed
Command: "JOIN", To: channel,
},
)
}
// PartChannel leaves a channel.
func (client *Client) PartChannel(channel string) error {
return client.SendMessage(
&Message{ //nolint:exhaustruct // only command+to needed
Command: "PART", To: channel,
},
)
}
// ListChannels returns all channels on the server.
func (client *Client) ListChannels() (
[]Channel, error,
) {
data, err := client.do(
http.MethodGet, "/api/v1/channels", nil,
)
if err != nil {
return nil, err
}
var channels []Channel
err = json.Unmarshal(data, &channels)
if err != nil {
return nil, fmt.Errorf(
"decode channels: %w", err,
)
}
return channels, nil
}
// GetMembers returns members of a channel.
func (client *Client) GetMembers(
channel string,
) ([]string, error) {
name := strings.TrimPrefix(channel, "#")
data, err := client.do(
http.MethodGet,
"/api/v1/channels/"+url.PathEscape(name)+
"/members",
nil,
)
if err != nil {
return nil, err
}
var members []string
err = json.Unmarshal(data, &members)
if err != nil {
return nil, fmt.Errorf(
"unexpected members format: %w", err,
)
}
return members, nil
}
// GetServerInfo returns server info.
func (client *Client) GetServerInfo() (
*ServerInfo, error,
) {
data, err := client.do(
http.MethodGet, "/api/v1/server", nil,
)
if err != nil {
return nil, err
}
var info ServerInfo
err = json.Unmarshal(data, &info)
if err != nil {
return nil, fmt.Errorf(
"decode server info: %w", err,
)
}
return &info, nil
}
func (client *Client) do(
method, path string,
body any,
) ([]byte, error) {
@ -266,25 +271,27 @@ func (c *Client) do(
bodyReader = bytes.NewReader(data)
}
req, err := http.NewRequestWithContext(
request, err := http.NewRequestWithContext(
context.Background(),
method,
c.BaseURL+path,
client.BaseURL+path,
bodyReader,
)
if err != nil {
return nil, fmt.Errorf("request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
request.Header.Set(
"Content-Type", "application/json",
)
if c.Token != "" {
req.Header.Set(
"Authorization", "Bearer "+c.Token,
if client.Token != "" {
request.Header.Set(
"Authorization", "Bearer "+client.Token,
)
}
resp, err := c.HTTPClient.Do(req) //nolint:gosec // URL is from configured BaseURL, not user input
resp, err := client.HTTPClient.Do(request)
if err != nil {
return nil, fmt.Errorf("http: %w", err)
}

13
cmd/chat-cli/api/types.go
View File

@ -1,4 +1,3 @@
// Package chatapi provides API types and client for chat-cli.
package chatapi
import "time"
@ -36,19 +35,19 @@ type Message struct {
// BodyLines returns the body as a string slice.
func (m *Message) BodyLines() []string {
switch v := m.Body.(type) {
switch bodyVal := m.Body.(type) {
case []any:
lines := make([]string, 0, len(v))
lines := make([]string, 0, len(bodyVal))
for _, item := range v {
if s, ok := item.(string); ok {
lines = append(lines, s)
for _, item := range bodyVal {
if str, ok := item.(string); ok {
lines = append(lines, str)
}
}
return lines
case []string:
return v
return bodyVal
default:
return nil
}

148
cmd/chat-cli/main.go
View File

@ -32,7 +32,7 @@ type App struct {
}
func main() {
app := &App{
app := &App{ //nolint:exhaustruct
ui: NewUI(),
nick: "guest",
}
@ -85,7 +85,7 @@ func (a *App) handleInput(text string) {
return
}
err := a.client.SendMessage(&api.Message{
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
Command: "PRIVMSG",
To: target,
Body: []string{text},
@ -98,7 +98,7 @@ func (a *App) handleInput(text string) {
return
}
ts := time.Now().Format(timeFormat)
timestamp := time.Now().Format(timeFormat)
a.mu.Lock()
nick := a.nick
@ -106,7 +106,7 @@ func (a *App) handleInput(text string) {
a.ui.AddLine(target, fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s",
ts, nick, text,
timestamp, nick, text,
))
}
@ -123,40 +123,36 @@ func (a *App) handleCommand(text string) {
}
func (a *App) dispatchCommand(cmd, args string) {
argCmds := map[string]func(string){
"/connect": a.cmdConnect,
"/nick": a.cmdNick,
"/join": a.cmdJoin,
"/part": a.cmdPart,
"/msg": a.cmdMsg,
"/query": a.cmdQuery,
"/topic": a.cmdTopic,
"/window": a.cmdWindow,
"/w": a.cmdWindow,
switch cmd {
case "/connect":
a.cmdConnect(args)
case "/nick":
a.cmdNick(args)
case "/join":
a.cmdJoin(args)
case "/part":
a.cmdPart(args)
case "/msg":
a.cmdMsg(args)
case "/query":
a.cmdQuery(args)
case "/topic":
a.cmdTopic(args)
case "/names":
a.cmdNames()
case "/list":
a.cmdList()
case "/window", "/w":
a.cmdWindow(args)
case "/quit":
a.cmdQuit()
case "/help":
a.cmdHelp()
default:
a.ui.AddStatus(
"[red]Unknown command: " + cmd,
)
}
if fn, ok := argCmds[cmd]; ok {
fn(args)
return
}
noArgCmds := map[string]func(){
"/names": a.cmdNames,
"/list": a.cmdList,
"/quit": a.cmdQuit,
"/help": a.cmdHelp,
}
if fn, ok := noArgCmds[cmd]; ok {
fn()
return
}
a.ui.AddStatus(
"[red]Unknown command: " + cmd,
)
}
func (a *App) cmdConnect(serverURL string) {
@ -231,7 +227,7 @@ func (a *App) cmdNick(nick string) {
return
}
err := a.client.SendMessage(&api.Message{
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
Command: "NICK",
Body: []string{nick},
})
@ -366,7 +362,7 @@ func (a *App) cmdMsg(args string) {
return
}
err := a.client.SendMessage(&api.Message{
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
Command: "PRIVMSG",
To: target,
Body: []string{text},
@ -379,11 +375,11 @@ func (a *App) cmdMsg(args string) {
return
}
ts := time.Now().Format(timeFormat)
timestamp := time.Now().Format(timeFormat)
a.ui.AddLine(target, fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s",
ts, nick, text,
timestamp, nick, text,
))
}
@ -424,7 +420,7 @@ func (a *App) cmdTopic(args string) {
}
if args == "" {
err := a.client.SendMessage(&api.Message{
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
Command: "TOPIC",
To: target,
})
@ -437,7 +433,7 @@ func (a *App) cmdTopic(args string) {
return
}
err := a.client.SendMessage(&api.Message{
err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
Command: "TOPIC",
To: target,
Body: []string{args},
@ -523,18 +519,18 @@ func (a *App) cmdWindow(args string) {
return
}
var n int
var bufIndex int
_, _ = fmt.Sscanf(args, "%d", &n)
_, _ = fmt.Sscanf(args, "%d", &bufIndex)
a.ui.SwitchBuffer(n)
a.ui.SwitchBuffer(bufIndex)
a.mu.Lock()
nick := a.nick
a.mu.Unlock()
if n >= 0 && n < a.ui.BufferCount() {
buf := a.ui.buffers[n]
if bufIndex >= 0 && bufIndex < a.ui.BufferCount() {
buf := a.ui.buffers[bufIndex]
if buf.Name != "(status)" {
a.mu.Lock()
a.target = buf.Name
@ -554,7 +550,7 @@ func (a *App) cmdQuit() {
if a.connected && a.client != nil {
_ = a.client.SendMessage(
&api.Message{Command: "QUIT"},
&api.Message{Command: "QUIT"}, //nolint:exhaustruct
)
}
@ -629,7 +625,7 @@ func (a *App) pollLoop() {
}
func (a *App) handleServerMessage(msg *api.Message) {
ts := a.formatTS(msg)
timestamp := a.formatTS(msg)
a.mu.Lock()
myNick := a.nick
@ -637,21 +633,21 @@ func (a *App) handleServerMessage(msg *api.Message) {
switch msg.Command {
case "PRIVMSG":
a.handlePrivmsgEvent(msg, ts, myNick)
a.handlePrivmsgEvent(msg, timestamp, myNick)
case "JOIN":
a.handleJoinEvent(msg, ts)
a.handleJoinEvent(msg, timestamp)
case "PART":
a.handlePartEvent(msg, ts)
a.handlePartEvent(msg, timestamp)
case "QUIT":
a.handleQuitEvent(msg, ts)
a.handleQuitEvent(msg, timestamp)
case "NICK":
a.handleNickEvent(msg, ts, myNick)
a.handleNickEvent(msg, timestamp, myNick)
case "NOTICE":
a.handleNoticeEvent(msg, ts)
a.handleNoticeEvent(msg, timestamp)
case "TOPIC":
a.handleTopicEvent(msg, ts)
a.handleTopicEvent(msg, timestamp)
default:
a.handleDefaultEvent(msg, ts)
a.handleDefaultEvent(msg, timestamp)
}
}
@ -664,7 +660,7 @@ func (a *App) formatTS(msg *api.Message) string {
}
func (a *App) handlePrivmsgEvent(
msg *api.Message, ts, myNick string,
msg *api.Message, timestamp, myNick string,
) {
lines := msg.BodyLines()
text := strings.Join(lines, " ")
@ -680,12 +676,12 @@ func (a *App) handlePrivmsgEvent(
a.ui.AddLine(target, fmt.Sprintf(
"[gray]%s [green]<%s>[white] %s",
ts, msg.From, text,
timestamp, msg.From, text,
))
}
func (a *App) handleJoinEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
if msg.To == "" {
return
@ -693,12 +689,12 @@ func (a *App) handleJoinEvent(
a.ui.AddLine(msg.To, fmt.Sprintf(
"[gray]%s [yellow]*** %s has joined %s",
ts, msg.From, msg.To,
timestamp, msg.From, msg.To,
))
}
func (a *App) handlePartEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
if msg.To == "" {
return
@ -710,18 +706,18 @@ func (a *App) handlePartEvent(
if reason != "" {
a.ui.AddLine(msg.To, fmt.Sprintf(
"[gray]%s [yellow]*** %s has left %s (%s)",
ts, msg.From, msg.To, reason,
timestamp, msg.From, msg.To, reason,
))
} else {
a.ui.AddLine(msg.To, fmt.Sprintf(
"[gray]%s [yellow]*** %s has left %s",
ts, msg.From, msg.To,
timestamp, msg.From, msg.To,
))
}
}
func (a *App) handleQuitEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
lines := msg.BodyLines()
reason := strings.Join(lines, " ")
@ -729,18 +725,18 @@ func (a *App) handleQuitEvent(
if reason != "" {
a.ui.AddStatus(fmt.Sprintf(
"[gray]%s [yellow]*** %s has quit (%s)",
ts, msg.From, reason,
timestamp, msg.From, reason,
))
} else {
a.ui.AddStatus(fmt.Sprintf(
"[gray]%s [yellow]*** %s has quit",
ts, msg.From,
timestamp, msg.From,
))
}
}
func (a *App) handleNickEvent(
msg *api.Message, ts, myNick string,
msg *api.Message, timestamp, myNick string,
) {
lines := msg.BodyLines()
@ -761,24 +757,24 @@ func (a *App) handleNickEvent(
a.ui.AddStatus(fmt.Sprintf(
"[gray]%s [yellow]*** %s is now known as %s",
ts, msg.From, newNick,
timestamp, msg.From, newNick,
))
}
func (a *App) handleNoticeEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
lines := msg.BodyLines()
text := strings.Join(lines, " ")
a.ui.AddStatus(fmt.Sprintf(
"[gray]%s [magenta]--%s-- %s",
ts, msg.From, text,
timestamp, msg.From, text,
))
}
func (a *App) handleTopicEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
if msg.To == "" {
return
@ -789,12 +785,12 @@ func (a *App) handleTopicEvent(
a.ui.AddLine(msg.To, fmt.Sprintf(
"[gray]%s [cyan]*** %s set topic: %s",
ts, msg.From, text,
timestamp, msg.From, text,
))
}
func (a *App) handleDefaultEvent(
msg *api.Message, ts string,
msg *api.Message, timestamp string,
) {
lines := msg.BodyLines()
text := strings.Join(lines, " ")
@ -802,7 +798,7 @@ func (a *App) handleDefaultEvent(
if text != "" {
a.ui.AddStatus(fmt.Sprintf(
"[gray]%s [white][%s] %s",
ts, msg.Command, text,
timestamp, msg.Command, text,
))
}
}

21
cmd/chat-cli/ui.go
View File

@ -32,10 +32,10 @@ type UI struct {
// NewUI creates the tview-based IRC-like UI.
func NewUI() *UI {
ui := &UI{
ui := &UI{ //nolint:exhaustruct,varnamelen // fields set below; ui is idiomatic
app: tview.NewApplication(),
buffers: []*Buffer{
{Name: "(status)", Lines: nil},
{Name: "(status)", Lines: nil, Unread: 0},
},
}
@ -58,7 +58,12 @@ func NewUI() *UI {
// Run starts the UI event loop (blocks).
func (ui *UI) Run() error {
return ui.app.Run()
err := ui.app.Run()
if err != nil {
return fmt.Errorf("run ui: %w", err)
}
return nil
}
// Stop stops the UI.
@ -100,15 +105,15 @@ func (ui *UI) AddStatus(line string) {
}
// SwitchBuffer switches to the buffer at index n.
func (ui *UI) SwitchBuffer(n int) {
func (ui *UI) SwitchBuffer(bufIndex int) {
ui.app.QueueUpdateDraw(func() {
if n < 0 || n >= len(ui.buffers) {
if bufIndex < 0 || bufIndex >= len(ui.buffers) {
return
}
ui.currentBuffer = n
ui.currentBuffer = bufIndex
buf := ui.buffers[n]
buf := ui.buffers[bufIndex]
buf.Unread = 0
ui.messages.Clear()
@ -282,7 +287,7 @@ func (ui *UI) getOrCreateBuffer(name string) *Buffer {
}
}
buf := &Buffer{Name: name}
buf := &Buffer{Name: name, Lines: nil, Unread: 0}
ui.buffers = append(ui.buffers, buf)
return buf

32
internal/broker/broker.go
View File

@ -8,25 +8,28 @@ import (
// Broker notifies waiting clients when new messages are available.
type Broker struct {
mu sync.Mutex
listeners map[int64][]chan struct{} // userID -> list of waiting channels
listeners map[int64][]chan struct{}
}
// New creates a new Broker.
func New() *Broker {
return &Broker{
return &Broker{ //nolint:exhaustruct // mu has zero-value default
listeners: make(map[int64][]chan struct{}),
}
}
// Wait returns a channel that will be closed when a message is available for the user.
// Wait returns a channel that will be closed when a message
// is available for the user.
func (b *Broker) Wait(userID int64) chan struct{} {
ch := make(chan struct{}, 1)
waitCh := make(chan struct{}, 1)
b.mu.Lock()
b.listeners[userID] = append(b.listeners[userID], ch)
b.listeners[userID] = append(
b.listeners[userID], waitCh,
)
b.mu.Unlock()
return ch
return waitCh
}
// Notify wakes up all waiting clients for a user.
@ -36,24 +39,29 @@ func (b *Broker) Notify(userID int64) {
delete(b.listeners, userID)
b.mu.Unlock()
for _, ch := range waiters {
for _, waiter := range waiters {
select {
case ch <- struct{}{}:
case waiter <- struct{}{}:
default:
}
}
}
// Remove removes a specific wait channel (for cleanup on timeout).
func (b *Broker) Remove(userID int64, ch chan struct{}) {
func (b *Broker) Remove(
userID int64,
waitCh chan struct{},
) {
b.mu.Lock()
defer b.mu.Unlock()
waiters := b.listeners[userID]
for i, w := range waiters {
if w == ch {
b.listeners[userID] = append(waiters[:i], waiters[i+1:]...)
for i, waiter := range waiters {
if waiter == waitCh {
b.listeners[userID] = append(
waiters[:i], waiters[i+1:]...,
)
break
}

67
internal/broker/broker_test.go
View File

@ -11,8 +11,8 @@ import (
func TestNewBroker(t *testing.T) {
t.Parallel()
b := broker.New()
if b == nil {
brk := broker.New()
if brk == nil {
t.Fatal("expected non-nil broker")
}
}
@ -20,16 +20,16 @@ func TestNewBroker(t *testing.T) {
func TestWaitAndNotify(t *testing.T) {
t.Parallel()
b := broker.New()
ch := b.Wait(1)
brk := broker.New()
waitCh := brk.Wait(1)
go func() {
time.Sleep(10 * time.Millisecond)
b.Notify(1)
brk.Notify(1)
}()
select {
case <-ch:
case <-waitCh:
case <-time.After(2 * time.Second):
t.Fatal("timeout")
}
@ -38,21 +38,22 @@ func TestWaitAndNotify(t *testing.T) {
func TestNotifyWithoutWaiters(t *testing.T) {
t.Parallel()
b := broker.New()
b.Notify(42) // should not panic
brk := broker.New()
brk.Notify(42) // should not panic.
}
func TestRemove(t *testing.T) {
t.Parallel()
b := broker.New()
ch := b.Wait(1)
b.Remove(1, ch)
brk := broker.New()
waitCh := brk.Wait(1)
b.Notify(1)
brk.Remove(1, waitCh)
brk.Notify(1)
select {
case <-ch:
case <-waitCh:
t.Fatal("should not receive after remove")
case <-time.After(50 * time.Millisecond):
}
@ -61,20 +62,20 @@ func TestRemove(t *testing.T) {
func TestMultipleWaiters(t *testing.T) {
t.Parallel()
b := broker.New()
ch1 := b.Wait(1)
ch2 := b.Wait(1)
brk := broker.New()
waitCh1 := brk.Wait(1)
waitCh2 := brk.Wait(1)
b.Notify(1)
brk.Notify(1)
select {
case <-ch1:
case <-waitCh1:
case <-time.After(time.Second):
t.Fatal("ch1 timeout")
}
select {
case <-ch2:
case <-waitCh2:
case <-time.After(time.Second):
t.Fatal("ch2 timeout")
}
@ -83,36 +84,38 @@ func TestMultipleWaiters(t *testing.T) {
func TestConcurrentWaitNotify(t *testing.T) {
t.Parallel()
b := broker.New()
brk := broker.New()
var wg sync.WaitGroup
var waitGroup sync.WaitGroup
const concurrency = 100
for i := range concurrency {
wg.Add(1)
for idx := range concurrency {
waitGroup.Add(1)
go func(uid int64) {
defer wg.Done()
defer waitGroup.Done()
ch := b.Wait(uid)
b.Notify(uid)
waitCh := brk.Wait(uid)
brk.Notify(uid)
select {
case <-ch:
case <-waitCh:
case <-time.After(time.Second):
t.Error("timeout")
}
}(int64(i % 10))
}(int64(idx % 10))
}
wg.Wait()
waitGroup.Wait()
}
func TestRemoveNonexistent(t *testing.T) {
t.Parallel()
b := broker.New()
ch := make(chan struct{}, 1)
b.Remove(999, ch) // should not panic
brk := broker.New()
waitCh := make(chan struct{}, 1)
brk.Remove(999, waitCh) // should not panic.
}

12
internal/config/config.go
View File

@ -41,7 +41,9 @@ type Config struct {
}
// New creates a new Config by reading from files and environment variables.
func New(_ fx.Lifecycle, params Params) (*Config, error) {
func New(
_ fx.Lifecycle, params Params,
) (*Config, error) {
log := params.Logger.Get()
name := params.Globals.Appname
@ -74,7 +76,7 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
}
}
s := &Config{
cfg := &Config{
DBURL: viper.GetString("DBURL"),
Debug: viper.GetBool("DEBUG"),
Port: viper.GetInt("PORT"),
@ -92,10 +94,10 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
params: &params,
}
if s.Debug {
if cfg.Debug {
params.Logger.EnableDebugLogging()
s.log = params.Logger.Get()
cfg.log = params.Logger.Get()
}
return s, nil
return cfg, nil
}

136
internal/db/db.go
View File

@ -37,93 +37,93 @@ type Params struct {
// Database manages the SQLite connection and migrations.
type Database struct {
db *sql.DB
conn *sql.DB
log *slog.Logger
params *Params
}
// New creates a new Database and registers lifecycle hooks.
func New(
lc fx.Lifecycle,
lifecycle fx.Lifecycle,
params Params,
) (*Database, error) {
s := new(Database)
s.params = &params
s.log = params.Logger.Get()
database := &Database{ //nolint:exhaustruct // conn set in OnStart
params: &params,
log: params.Logger.Get(),
}
s.log.Info("Database instantiated")
database.log.Info("Database instantiated")
lc.Append(fx.Hook{
lifecycle.Append(fx.Hook{
OnStart: func(ctx context.Context) error {
s.log.Info("Database OnStart Hook")
database.log.Info("Database OnStart Hook")
return s.connect(ctx)
return database.connect(ctx)
},
OnStop: func(_ context.Context) error {
s.log.Info("Database OnStop Hook")
database.log.Info("Database OnStop Hook")
if s.db != nil {
return s.db.Close()
if database.conn != nil {
closeErr := database.conn.Close()
if closeErr != nil {
return fmt.Errorf(
"close db: %w", closeErr,
)
}
}
return nil
},
})
return s, nil
return database, nil
}
// GetDB returns the underlying sql.DB connection.
func (s *Database) GetDB() *sql.DB {
return s.db
func (database *Database) GetDB() *sql.DB {
return database.conn
}
func (s *Database) connect(ctx context.Context) error {
dbURL := s.params.Config.DBURL
func (database *Database) connect(ctx context.Context) error {
dbURL := database.params.Config.DBURL
if dbURL == "" {
dbURL = "file:./data.db?_journal_mode=WAL&_busy_timeout=5000"
}
s.log.Info("connecting to database", "url", dbURL)
database.log.Info(
"connecting to database", "url", dbURL,
)
d, err := sql.Open("sqlite", dbURL)
conn, err := sql.Open("sqlite", dbURL)
if err != nil {
s.log.Error(
"failed to open database", "error", err,
)
return err
return fmt.Errorf("open database: %w", err)
}
err = d.PingContext(ctx)
err = conn.PingContext(ctx)
if err != nil {
s.log.Error(
"failed to ping database", "error", err,
)
return err
return fmt.Errorf("ping database: %w", err)
}
d.SetMaxOpenConns(1)
conn.SetMaxOpenConns(1)
s.db = d
s.log.Info("database connected")
database.conn = conn
database.log.Info("database connected")
_, err = s.db.ExecContext(
_, err = database.conn.ExecContext(
ctx, "PRAGMA foreign_keys = ON",
)
if err != nil {
return fmt.Errorf("enable foreign keys: %w", err)
}
_, err = s.db.ExecContext(
_, err = database.conn.ExecContext(
ctx, "PRAGMA busy_timeout = 5000",
)
if err != nil {
return fmt.Errorf("set busy timeout: %w", err)
}
return s.runMigrations(ctx)
return database.runMigrations(ctx)
}
type migration struct {
@ -132,10 +132,10 @@ type migration struct {
sql string
}
func (s *Database) runMigrations(
func (database *Database) runMigrations(
ctx context.Context,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`CREATE TABLE IF NOT EXISTS schema_migrations (
version INTEGER PRIMARY KEY,
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)`)
@ -145,37 +145,37 @@ func (s *Database) runMigrations(
)
}
migrations, err := s.loadMigrations()
migrations, err := database.loadMigrations()
if err != nil {
return err
}
for _, m := range migrations {
err = s.applyMigration(ctx, m)
for _, mig := range migrations {
err = database.applyMigration(ctx, mig)
if err != nil {
return err
}
}
s.log.Info("database migrations complete")
database.log.Info("database migrations complete")
return nil
}
func (s *Database) applyMigration(
func (database *Database) applyMigration(
ctx context.Context,
m migration,
mig migration,
) error {
var exists int
err := s.db.QueryRowContext(ctx,
err := database.conn.QueryRowContext(ctx,
`SELECT COUNT(*) FROM schema_migrations
WHERE version = ?`,
m.version,
mig.version,
).Scan(&exists)
if err != nil {
return fmt.Errorf(
"check migration %d: %w", m.version, err,
"check migration %d: %w", mig.version, err,
)
}
@ -183,55 +183,63 @@ func (s *Database) applyMigration(
return nil
}
s.log.Info(
database.log.Info(
"applying migration",
"version", m.version,
"name", m.name,
"version", mig.version,
"name", mig.name,
)
return s.execMigration(ctx, m)
return database.execMigration(ctx, mig)
}
func (s *Database) execMigration(
func (database *Database) execMigration(
ctx context.Context,
m migration,
mig migration,
) error {
tx, err := s.db.BeginTx(ctx, nil)
transaction, err := database.conn.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf(
"begin tx for migration %d: %w",
m.version, err,
mig.version, err,
)
}
_, err = tx.ExecContext(ctx, m.sql)
_, err = transaction.ExecContext(ctx, mig.sql)
if err != nil {
_ = tx.Rollback()
_ = transaction.Rollback()
return fmt.Errorf(
"apply migration %d (%s): %w",
m.version, m.name, err,
mig.version, mig.name, err,
)
}
_, err = tx.ExecContext(ctx,
_, err = transaction.ExecContext(ctx,
`INSERT INTO schema_migrations (version)
VALUES (?)`,
m.version,
mig.version,
)
if err != nil {
_ = tx.Rollback()
_ = transaction.Rollback()
return fmt.Errorf(
"record migration %d: %w",
m.version, err,
mig.version, err,
)
}
return tx.Commit()
err = transaction.Commit()
if err != nil {
return fmt.Errorf(
"commit migration %d: %w",
mig.version, err,
)
}
return nil
}
func (s *Database) loadMigrations() (
func (database *Database) loadMigrations() (
[]migration,
error,
) {

33
internal/db/export_test.go
View File

@ -13,35 +13,48 @@ var testDBCounter atomic.Int64
// NewTestDatabase creates an in-memory database for testing.
func NewTestDatabase() (*Database, error) {
n := testDBCounter.Add(1)
counter := testDBCounter.Add(1)
dsn := fmt.Sprintf(
"file:testdb%d?mode=memory"+
"&cache=shared&_pragma=foreign_keys(1)",
n,
counter,
)
d, err := sql.Open("sqlite", dsn)
conn, err := sql.Open("sqlite", dsn)
if err != nil {
return nil, err
return nil, fmt.Errorf("open test db: %w", err)
}
database := &Database{db: d, log: slog.Default()}
database := &Database{ //nolint:exhaustruct // test helper, params not needed
conn: conn,
log: slog.Default(),
}
err = database.runMigrations(context.Background())
if err != nil {
closeErr := d.Close()
closeErr := conn.Close()
if closeErr != nil {
return nil, closeErr
return nil, fmt.Errorf(
"close after migration failure: %w",
closeErr,
)
}
return nil, err
return nil, fmt.Errorf(
"run test migrations: %w", err,
)
}
return database, nil
}
// Close closes the underlying database connection.
func (s *Database) Close() error {
return s.db.Close()
func (database *Database) Close() error {
err := database.conn.Close()
if err != nil {
return fmt.Errorf("close database: %w", err)
}
return nil
}

345
internal/db/queries.go
View File

@ -18,11 +18,15 @@ const (
defaultHistLimit = 50
)
func generateToken() string {
b := make([]byte, tokenBytes)
_, _ = rand.Read(b)
func generateToken() (string, error) {
buf := make([]byte, tokenBytes)
return hex.EncodeToString(b)
_, err := rand.Read(buf)
if err != nil {
return "", fmt.Errorf("generate token: %w", err)
}
return hex.EncodeToString(buf), nil
}
// IRCMessage is the IRC envelope for all messages.
@ -52,14 +56,18 @@ type MemberInfo struct {
}
// CreateUser registers a new user with the given nick.
func (s *Database) CreateUser(
func (database *Database) CreateUser(
ctx context.Context,
nick string,
) (int64, string, error) {
token := generateToken()
token, err := generateToken()
if err != nil {
return 0, "", err
}
now := time.Now()
res, err := s.db.ExecContext(ctx,
res, err := database.conn.ExecContext(ctx,
`INSERT INTO users
(nick, token, created_at, last_seen)
VALUES (?, ?, ?, ?)`,
@ -68,90 +76,88 @@ func (s *Database) CreateUser(
return 0, "", fmt.Errorf("create user: %w", err)
}
id, _ := res.LastInsertId()
userID, _ := res.LastInsertId()
return id, token, nil
return userID, token, nil
}
// GetUserByToken returns user id and nick for a token.
func (s *Database) GetUserByToken(
func (database *Database) GetUserByToken(
ctx context.Context,
token string,
) (int64, string, error) {
var id int64
var userID int64
var nick string
err := s.db.QueryRowContext(
err := database.conn.QueryRowContext(
ctx,
"SELECT id, nick FROM users WHERE token = ?",
token,
).Scan(&id, &nick)
).Scan(&userID, &nick)
if err != nil {
return 0, "", err
return 0, "", fmt.Errorf("get user by token: %w", err)
}
_, _ = s.db.ExecContext(
_, _ = database.conn.ExecContext(
ctx,
"UPDATE users SET last_seen = ? WHERE id = ?",
time.Now(), id,
time.Now(), userID,
)
return id, nick, nil
return userID, nick, nil
}
// GetUserByNick returns user id for a given nick.
func (s *Database) GetUserByNick(
func (database *Database) GetUserByNick(
ctx context.Context,
nick string,
) (int64, error) {
var id int64
var userID int64
err := s.db.QueryRowContext(
err := database.conn.QueryRowContext(
ctx,
"SELECT id FROM users WHERE nick = ?",
nick,
).Scan(&id)
).Scan(&userID)
if err != nil {
return 0, fmt.Errorf("get user by nick: %w", err)
}
return id, err
return userID, nil
}
// GetChannelByName returns the channel ID for a name.
func (s *Database) GetChannelByName(
func (database *Database) GetChannelByName(
ctx context.Context,
name string,
) (int64, error) {
var id int64
var channelID int64
err := s.db.QueryRowContext(
err := database.conn.QueryRowContext(
ctx,
"SELECT id FROM channels WHERE name = ?",
name,
).Scan(&id)
).Scan(&channelID)
if err != nil {
return 0, fmt.Errorf(
"get channel by name: %w", err,
)
}
return id, err
return channelID, nil
}
// GetOrCreateChannel returns channel id, creating if needed.
func (s *Database) GetOrCreateChannel(
// Uses INSERT OR IGNORE to avoid TOCTOU races.
func (database *Database) GetOrCreateChannel(
ctx context.Context,
name string,
) (int64, error) {
var id int64
err := s.db.QueryRowContext(
ctx,
"SELECT id FROM channels WHERE name = ?",
name,
).Scan(&id)
if err == nil {
return id, nil
}
now := time.Now()
res, err := s.db.ExecContext(ctx,
`INSERT INTO channels
_, err := database.conn.ExecContext(ctx,
`INSERT OR IGNORE INTO channels
(name, created_at, updated_at)
VALUES (?, ?, ?)`,
name, now, now)
@ -159,51 +165,71 @@ func (s *Database) GetOrCreateChannel(
return 0, fmt.Errorf("create channel: %w", err)
}
id, _ = res.LastInsertId()
var channelID int64
return id, nil
err = database.conn.QueryRowContext(
ctx,
"SELECT id FROM channels WHERE name = ?",
name,
).Scan(&channelID)
if err != nil {
return 0, fmt.Errorf("get channel: %w", err)
}
return channelID, nil
}
// JoinChannel adds a user to a channel.
func (s *Database) JoinChannel(
func (database *Database) JoinChannel(
ctx context.Context,
channelID, userID int64,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`INSERT OR IGNORE INTO channel_members
(channel_id, user_id, joined_at)
VALUES (?, ?, ?)`,
channelID, userID, time.Now())
if err != nil {
return fmt.Errorf("join channel: %w", err)
}
return err
return nil
}
// PartChannel removes a user from a channel.
func (s *Database) PartChannel(
func (database *Database) PartChannel(
ctx context.Context,
channelID, userID int64,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`DELETE FROM channel_members
WHERE channel_id = ? AND user_id = ?`,
channelID, userID)
if err != nil {
return fmt.Errorf("part channel: %w", err)
}
return err
return nil
}
// DeleteChannelIfEmpty removes a channel with no members.
func (s *Database) DeleteChannelIfEmpty(
func (database *Database) DeleteChannelIfEmpty(
ctx context.Context,
channelID int64,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`DELETE FROM channels WHERE id = ?
AND NOT EXISTS
(SELECT 1 FROM channel_members
WHERE channel_id = ?)`,
channelID, channelID)
if err != nil {
return fmt.Errorf(
"delete channel if empty: %w", err,
)
}
return err
return nil
}
// scanChannels scans rows into a ChannelInfo slice.
@ -215,19 +241,21 @@ func scanChannels(
var out []ChannelInfo
for rows.Next() {
var ch ChannelInfo
var chanInfo ChannelInfo
err := rows.Scan(&ch.ID, &ch.Name, &ch.Topic)
err := rows.Scan(
&chanInfo.ID, &chanInfo.Name, &chanInfo.Topic,
)
if err != nil {
return nil, err
return nil, fmt.Errorf("scan channel: %w", err)
}
out = append(out, ch)
out = append(out, chanInfo)
}
err := rows.Err()
if err != nil {
return nil, err
return nil, fmt.Errorf("rows error: %w", err)
}
if out == nil {
@ -238,11 +266,11 @@ func scanChannels(
}
// ListChannels returns channels the user has joined.
func (s *Database) ListChannels(
func (database *Database) ListChannels(
ctx context.Context,
userID int64,
) ([]ChannelInfo, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT c.id, c.name, c.topic
FROM channels c
INNER JOIN channel_members cm
@ -250,32 +278,34 @@ func (s *Database) ListChannels(
WHERE cm.user_id = ?
ORDER BY c.name`, userID)
if err != nil {
return nil, err
return nil, fmt.Errorf("list channels: %w", err)
}
return scanChannels(rows)
}
// ListAllChannels returns every channel.
func (s *Database) ListAllChannels(
func (database *Database) ListAllChannels(
ctx context.Context,
) ([]ChannelInfo, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT id, name, topic
FROM channels ORDER BY name`)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"list all channels: %w", err,
)
}
return scanChannels(rows)
}
// ChannelMembers returns all members of a channel.
func (s *Database) ChannelMembers(
func (database *Database) ChannelMembers(
ctx context.Context,
channelID int64,
) ([]MemberInfo, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT u.id, u.nick, u.last_seen
FROM users u
INNER JOIN channel_members cm
@ -283,7 +313,9 @@ func (s *Database) ChannelMembers(
WHERE cm.channel_id = ?
ORDER BY u.nick`, channelID)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"query channel members: %w", err,
)
}
defer func() { _ = rows.Close() }()
@ -291,19 +323,23 @@ func (s *Database) ChannelMembers(
var members []MemberInfo
for rows.Next() {
var m MemberInfo
var member MemberInfo
err = rows.Scan(&m.ID, &m.Nick, &m.LastSeen)
err = rows.Scan(
&member.ID, &member.Nick, &member.LastSeen,
)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"scan member: %w", err,
)
}
members = append(members, m)
members = append(members, member)
}
err = rows.Err()
if err != nil {
return nil, err
return nil, fmt.Errorf("rows error: %w", err)
}
if members == nil {
@ -313,6 +349,27 @@ func (s *Database) ChannelMembers(
return members, nil
}
// IsChannelMember checks if a user belongs to a channel.
func (database *Database) IsChannelMember(
ctx context.Context,
channelID, userID int64,
) (bool, error) {
var count int
err := database.conn.QueryRowContext(ctx,
`SELECT COUNT(*) FROM channel_members
WHERE channel_id = ? AND user_id = ?`,
channelID, userID,
).Scan(&count)
if err != nil {
return false, fmt.Errorf(
"check membership: %w", err,
)
}
return count > 0, nil
}
// scanInt64s scans rows into an int64 slice.
func scanInt64s(rows *sql.Rows) ([]int64, error) {
defer func() { _ = rows.Close() }()
@ -320,58 +377,64 @@ func scanInt64s(rows *sql.Rows) ([]int64, error) {
var ids []int64
for rows.Next() {
var id int64
var val int64
err := rows.Scan(&id)
err := rows.Scan(&val)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"scan int64: %w", err,
)
}
ids = append(ids, id)
ids = append(ids, val)
}
err := rows.Err()
if err != nil {
return nil, err
return nil, fmt.Errorf("rows error: %w", err)
}
return ids, nil
}
// GetChannelMemberIDs returns user IDs in a channel.
func (s *Database) GetChannelMemberIDs(
func (database *Database) GetChannelMemberIDs(
ctx context.Context,
channelID int64,
) ([]int64, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT user_id FROM channel_members
WHERE channel_id = ?`, channelID)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"get channel member ids: %w", err,
)
}
return scanInt64s(rows)
}
// GetUserChannelIDs returns channel IDs the user is in.
func (s *Database) GetUserChannelIDs(
func (database *Database) GetUserChannelIDs(
ctx context.Context,
userID int64,
) ([]int64, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT channel_id FROM channel_members
WHERE user_id = ?`, userID)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"get user channel ids: %w", err,
)
}
return scanInt64s(rows)
}
// InsertMessage stores a message and returns its DB ID.
func (s *Database) InsertMessage(
func (database *Database) InsertMessage(
ctx context.Context,
command, from, to string,
command, from, target string,
body json.RawMessage,
meta json.RawMessage,
) (int64, string, error) {
@ -386,38 +449,43 @@ func (s *Database) InsertMessage(
meta = json.RawMessage("{}")
}
res, err := s.db.ExecContext(ctx,
res, err := database.conn.ExecContext(ctx,
`INSERT INTO messages
(uuid, command, msg_from, msg_to,
body, meta, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?)`,
msgUUID, command, from, to,
msgUUID, command, from, target,
string(body), string(meta), now)
if err != nil {
return 0, "", err
return 0, "", fmt.Errorf(
"insert message: %w", err,
)
}
id, _ := res.LastInsertId()
dbID, _ := res.LastInsertId()
return id, msgUUID, nil
return dbID, msgUUID, nil
}
// EnqueueMessage adds a message to a user's queue.
func (s *Database) EnqueueMessage(
func (database *Database) EnqueueMessage(
ctx context.Context,
userID, messageID int64,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`INSERT OR IGNORE INTO client_queues
(user_id, message_id, created_at)
VALUES (?, ?, ?)`,
userID, messageID, time.Now())
if err != nil {
return fmt.Errorf("enqueue message: %w", err)
}
return err
return nil
}
// PollMessages returns queued messages for a user.
func (s *Database) PollMessages(
func (database *Database) PollMessages(
ctx context.Context,
userID, afterQueueID int64,
limit int,
@ -426,7 +494,7 @@ func (s *Database) PollMessages(
limit = defaultPollLimit
}
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT cq.id, m.uuid, m.command,
m.msg_from, m.msg_to,
m.body, m.meta, m.created_at
@ -437,7 +505,9 @@ func (s *Database) PollMessages(
ORDER BY cq.id ASC LIMIT ?`,
userID, afterQueueID, limit)
if err != nil {
return nil, afterQueueID, err
return nil, afterQueueID, fmt.Errorf(
"poll messages: %w", err,
)
}
msgs, lastQID, scanErr := scanMessages(
@ -451,7 +521,7 @@ func (s *Database) PollMessages(
}
// GetHistory returns message history for a target.
func (s *Database) GetHistory(
func (database *Database) GetHistory(
ctx context.Context,
target string,
beforeID int64,
@ -461,7 +531,7 @@ func (s *Database) GetHistory(
limit = defaultHistLimit
}
rows, err := s.queryHistory(
rows, err := database.queryHistory(
ctx, target, beforeID, limit,
)
if err != nil {
@ -482,14 +552,14 @@ func (s *Database) GetHistory(
return msgs, nil
}
func (s *Database) queryHistory(
func (database *Database) queryHistory(
ctx context.Context,
target string,
beforeID int64,
limit int,
) (*sql.Rows, error) {
if beforeID > 0 {
return s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT id, uuid, command, msg_from,
msg_to, body, meta, created_at
FROM messages
@ -497,9 +567,16 @@ func (s *Database) queryHistory(
AND command = 'PRIVMSG'
ORDER BY id DESC LIMIT ?`,
target, beforeID, limit)
if err != nil {
return nil, fmt.Errorf(
"query history: %w", err,
)
}
return rows, nil
}
return s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT id, uuid, command, msg_from,
msg_to, body, meta, created_at
FROM messages
@ -507,6 +584,11 @@ func (s *Database) queryHistory(
AND command = 'PRIVMSG'
ORDER BY id DESC LIMIT ?`,
target, limit)
if err != nil {
return nil, fmt.Errorf("query history: %w", err)
}
return rows, nil
}
func scanMessages(
@ -521,33 +603,37 @@ func scanMessages(
for rows.Next() {
var (
m IRCMessage
msg IRCMessage
qID int64
body, meta string
ts time.Time
createdAt time.Time
)
err := rows.Scan(
&qID, &m.ID, &m.Command,
&m.From, &m.To,
&body, &meta, &ts,
&qID, &msg.ID, &msg.Command,
&msg.From, &msg.To,
&body, &meta, &createdAt,
)
if err != nil {
return nil, fallbackQID, err
return nil, fallbackQID, fmt.Errorf(
"scan message: %w", err,
)
}
m.Body = json.RawMessage(body)
m.Meta = json.RawMessage(meta)
m.TS = ts.Format(time.RFC3339Nano)
m.DBID = qID
msg.Body = json.RawMessage(body)
msg.Meta = json.RawMessage(meta)
msg.TS = createdAt.Format(time.RFC3339Nano)
msg.DBID = qID
lastQID = qID
msgs = append(msgs, m)
msgs = append(msgs, msg)
}
err := rows.Err()
if err != nil {
return nil, fallbackQID, err
return nil, fallbackQID, fmt.Errorf(
"rows error: %w", err,
)
}
if msgs == nil {
@ -564,59 +650,70 @@ func reverseMessages(msgs []IRCMessage) {
}
// ChangeNick updates a user's nickname.
func (s *Database) ChangeNick(
func (database *Database) ChangeNick(
ctx context.Context,
userID int64,
newNick string,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
"UPDATE users SET nick = ? WHERE id = ?",
newNick, userID)
if err != nil {
return fmt.Errorf("change nick: %w", err)
}
return err
return nil
}
// SetTopic sets the topic for a channel.
func (s *Database) SetTopic(
func (database *Database) SetTopic(
ctx context.Context,
channelName, topic string,
) error {
_, err := s.db.ExecContext(ctx,
_, err := database.conn.ExecContext(ctx,
`UPDATE channels SET topic = ?,
updated_at = ? WHERE name = ?`,
topic, time.Now(), channelName)
if err != nil {
return fmt.Errorf("set topic: %w", err)
}
return err
return nil
}
// DeleteUser removes a user and all their data.
func (s *Database) DeleteUser(
func (database *Database) DeleteUser(
ctx context.Context,
userID int64,
) error {
_, err := s.db.ExecContext(
_, err := database.conn.ExecContext(
ctx,
"DELETE FROM users WHERE id = ?",
userID,
)
if err != nil {
return fmt.Errorf("delete user: %w", err)
}
return err
return nil
}
// GetAllChannelMembershipsForUser returns channels
// a user belongs to.
func (s *Database) GetAllChannelMembershipsForUser(
func (database *Database) GetAllChannelMembershipsForUser(
ctx context.Context,
userID int64,
) ([]ChannelInfo, error) {
rows, err := s.db.QueryContext(ctx,
rows, err := database.conn.QueryContext(ctx,
`SELECT c.id, c.name, c.topic
FROM channels c
INNER JOIN channel_members cm
ON cm.channel_id = c.id
WHERE cm.user_id = ?`, userID)
if err != nil {
return nil, err
return nil, fmt.Errorf(
"get memberships: %w", err,
)
}
return scanChannels(rows)

53
internal/db/queries_test.go
View File

@ -12,19 +12,19 @@ import (
func setupTestDB(t *testing.T) *db.Database {
t.Helper()
d, err := db.NewTestDatabase()
database, err := db.NewTestDatabase()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
closeErr := d.Close()
closeErr := database.Close()
if closeErr != nil {
t.Logf("close db: %v", closeErr)
}
})
return d
return database
}
func TestCreateUser(t *testing.T) {
@ -349,12 +349,30 @@ func TestSetTopic(t *testing.T) {
}
}
func insertTestMessage(
t *testing.T,
database *db.Database,
) (int64, int64) {
t.Helper()
func TestInsertMessage(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
body := json.RawMessage(`["hello"]`)
dbID, msgUUID, err := database.InsertMessage(
ctx, "PRIVMSG", "poller", "#test", body, nil,
)
if err != nil {
t.Fatal(err)
}
if dbID == 0 || msgUUID == "" {
t.Fatal("expected valid id and uuid")
}
}
func TestPollMessages(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
ctx := t.Context()
uid, _, err := database.CreateUser(ctx, "poller")
@ -364,11 +382,11 @@ func insertTestMessage(
body := json.RawMessage(`["hello"]`)
dbID, msgUUID, err := database.InsertMessage(
dbID, _, err := database.InsertMessage(
ctx, "PRIVMSG", "poller", "#test", body, nil,
)
if err != nil || dbID == 0 || msgUUID == "" {
t.Fatal("insert failed")
if err != nil {
t.Fatal(err)
}
err = database.EnqueueMessage(ctx, uid, dbID)
@ -376,19 +394,10 @@ func insertTestMessage(
t.Fatal(err)
}
return uid, dbID
}
func TestInsertAndPollMessages(t *testing.T) {
t.Parallel()
database := setupTestDB(t)
uid, _ := insertTestMessage(t, database)
const batchSize = 10
msgs, lastQID, err := database.PollMessages(
t.Context(), uid, 0, batchSize,
ctx, uid, 0, batchSize,
)
if err != nil {
t.Fatal(err)
@ -411,7 +420,7 @@ func TestInsertAndPollMessages(t *testing.T) {
}
msgs, _, _ = database.PollMessages(
t.Context(), uid, lastQID, batchSize,
ctx, uid, lastQID, batchSize,
)
if len(msgs) != 0 {

1120
internal/handlers/api.go
View File

File diff suppressed because it is too large Load Diff

1699
internal/handlers/api_test.go
View File

File diff suppressed because it is too large Load Diff

47
internal/handlers/handlers.go
View File

@ -40,40 +40,59 @@ type Handlers struct {
// New creates a new Handlers instance.
func New(
lc fx.Lifecycle,
lifecycle fx.Lifecycle,
params Params,
) (*Handlers, error) {
s := new(Handlers)
s.params = &params
s.log = params.Logger.Get()
s.hc = params.Healthcheck
s.broker = broker.New()
hdlr := &Handlers{
params: &params,
log: params.Logger.Get(),
hc: params.Healthcheck,
broker: broker.New(),
}
lc.Append(fx.Hook{
lifecycle.Append(fx.Hook{
OnStart: func(_ context.Context) error {
return nil
},
OnStop: func(_ context.Context) error {
return nil
},
})
return s, nil
return hdlr, nil
}
func (s *Handlers) respondJSON(
w http.ResponseWriter,
func (hdlr *Handlers) respondJSON(
writer http.ResponseWriter,
_ *http.Request,
data any,
status int,
) {
w.Header().Set(
writer.Header().Set(
"Content-Type",
"application/json; charset=utf-8",
)
w.WriteHeader(status)
writer.WriteHeader(status)
if data != nil {
err := json.NewEncoder(w).Encode(data)
err := json.NewEncoder(writer).Encode(data)
if err != nil {
s.log.Error("json encode error", "error", err)
hdlr.log.Error(
"json encode error", "error", err,
)
}
}
}
func (hdlr *Handlers) respondError(
writer http.ResponseWriter,
request *http.Request,
msg string,
status int,
) {
hdlr.respondJSON(
writer, request,
map[string]string{"error": msg},
status,
)
}

11
internal/handlers/healthcheck.go
View File

@ -7,9 +7,12 @@ import (
const httpStatusOK = 200
// HandleHealthCheck returns an HTTP handler for the health check endpoint.
func (s *Handlers) HandleHealthCheck() http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
resp := s.hc.Healthcheck()
s.respondJSON(w, req, resp, httpStatusOK)
func (hdlr *Handlers) HandleHealthCheck() http.HandlerFunc {
return func(
writer http.ResponseWriter,
request *http.Request,
) {
resp := hdlr.hc.Healthcheck()
hdlr.respondJSON(writer, request, resp, httpStatusOK)
}
}

36
internal/healthcheck/healthcheck.go
View File

@ -33,14 +33,17 @@ type Healthcheck struct {
}
// New creates a new Healthcheck instance.
func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
s := new(Healthcheck)
s.params = &params
s.log = params.Logger.Get()
func New(
lifecycle fx.Lifecycle, params Params,
) (*Healthcheck, error) {
hcheck := &Healthcheck{ //nolint:exhaustruct // StartupTime set in OnStart
params: &params,
log: params.Logger.Get(),
}
lc.Append(fx.Hook{
lifecycle.Append(fx.Hook{
OnStart: func(_ context.Context) error {
s.StartupTime = time.Now()
hcheck.StartupTime = time.Now()
return nil
},
@ -49,7 +52,7 @@ func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
},
})
return s, nil
return hcheck, nil
}
// Response is the JSON response returned by the health endpoint.
@ -64,19 +67,18 @@ type Response struct {
}
// Healthcheck returns the current health status of the server.
func (s *Healthcheck) Healthcheck() *Response {
resp := &Response{
func (hcheck *Healthcheck) Healthcheck() *Response {
return &Response{
Status: "ok",
Now: time.Now().UTC().Format(time.RFC3339Nano),
UptimeSeconds: int64(s.uptime().Seconds()),
UptimeHuman: s.uptime().String(),
Appname: s.params.Globals.Appname,
Version: s.params.Globals.Version,
UptimeSeconds: int64(hcheck.uptime().Seconds()),
UptimeHuman: hcheck.uptime().String(),
Appname: hcheck.params.Globals.Appname,
Version: hcheck.params.Globals.Version,
Maintenance: hcheck.params.Config.MaintenanceMode,
}
return resp
}
func (s *Healthcheck) uptime() time.Duration {
return time.Since(s.StartupTime)
func (hcheck *Healthcheck) uptime() time.Duration {
return time.Since(hcheck.StartupTime)
}

61
internal/logger/logger.go
View File

@ -23,51 +23,56 @@ type Logger struct {
params Params
}
// New creates a new Logger with appropriate handler based on terminal detection.
func New(_ fx.Lifecycle, params Params) (*Logger, error) {
l := new(Logger)
l.level = new(slog.LevelVar)
l.level.Set(slog.LevelInfo)
// New creates a new Logger with appropriate handler
// based on terminal detection.
func New(
_ fx.Lifecycle, params Params,
) (*Logger, error) {
logger := new(Logger)
logger.level = new(slog.LevelVar)
logger.level.Set(slog.LevelInfo)
tty := false
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
tty = true
}
var handler slog.Handler
if tty {
handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
Level: l.level,
AddSource: true,
})
} else {
handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: l.level,
AddSource: true,
})
opts := &slog.HandlerOptions{ //nolint:exhaustruct // ReplaceAttr optional
Level: logger.level,
AddSource: true,
}
l.log = slog.New(handler)
l.params = params
var handler slog.Handler
if tty {
handler = slog.NewTextHandler(os.Stdout, opts)
} else {
handler = slog.NewJSONHandler(os.Stdout, opts)
}
return l, nil
logger.log = slog.New(handler)
logger.params = params
return logger, nil
}
// EnableDebugLogging switches the log level to debug.
func (l *Logger) EnableDebugLogging() {
l.level.Set(slog.LevelDebug)
l.log.Debug("debug logging enabled", "debug", true)
func (logger *Logger) EnableDebugLogging() {
logger.level.Set(slog.LevelDebug)
logger.log.Debug(
"debug logging enabled", "debug", true,
)
}
// Get returns the underlying slog.Logger.
func (l *Logger) Get() *slog.Logger {
return l.log
func (logger *Logger) Get() *slog.Logger {
return logger.log
}
// Identify logs the application name and version at startup.
func (l *Logger) Identify() {
l.log.Info("starting",
"appname", l.params.Globals.Appname,
"version", l.params.Globals.Version,
func (logger *Logger) Identify() {
logger.log.Info("starting",
"appname", logger.params.Globals.Appname,
"version", logger.params.Globals.Version,
)
}

133
internal/middleware/middleware.go
View File

@ -11,7 +11,7 @@ import (
"git.eeqj.de/sneak/chat/internal/globals"
"git.eeqj.de/sneak/chat/internal/logger"
basicauth "github.com/99designs/basicauth-go"
"github.com/go-chi/chi/middleware"
chimw "github.com/go-chi/chi/middleware"
"github.com/go-chi/cors"
metrics "github.com/slok/go-http-metrics/metrics/prometheus"
ghmm "github.com/slok/go-http-metrics/middleware"
@ -38,25 +38,28 @@ type Middleware struct {
}
// New creates a new Middleware instance.
func New(_ fx.Lifecycle, params Params) (*Middleware, error) {
s := new(Middleware)
s.params = &params
s.log = params.Logger.Get()
func New(
_ fx.Lifecycle, params Params,
) (*Middleware, error) {
mware := &Middleware{
params: &params,
log: params.Logger.Get(),
}
return s, nil
return mware, nil
}
func ipFromHostPort(hp string) string {
h, _, err := net.SplitHostPort(hp)
func ipFromHostPort(hostPort string) string {
host, _, err := net.SplitHostPort(hostPort)
if err != nil {
return ""
}
if len(h) > 0 && h[0] == '[' {
return h[1 : len(h)-1]
if len(host) > 0 && host[0] == '[' {
return host[1 : len(host)-1]
}
return h
return host
}
type loggingResponseWriter struct {
@ -65,9 +68,15 @@ type loggingResponseWriter struct {
statusCode int
}
// newLoggingResponseWriter wraps a ResponseWriter to capture the status code.
func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
return &loggingResponseWriter{w, http.StatusOK}
// newLoggingResponseWriter wraps a ResponseWriter
// to capture the status code.
func newLoggingResponseWriter(
writer http.ResponseWriter,
) *loggingResponseWriter {
return &loggingResponseWriter{
ResponseWriter: writer,
statusCode: http.StatusOK,
}
}
func (lrw *loggingResponseWriter) WriteHeader(code int) {
@ -76,43 +85,57 @@ func (lrw *loggingResponseWriter) WriteHeader(code int) {
}
// Logging returns middleware that logs each HTTP request.
func (s *Middleware) Logging() func(http.Handler) http.Handler {
func (mware *Middleware) Logging() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
lrw := newLoggingResponseWriter(w)
ctx := r.Context()
return http.HandlerFunc(
func(
writer http.ResponseWriter,
request *http.Request,
) {
start := time.Now()
lrw := newLoggingResponseWriter(writer)
ctx := request.Context()
defer func() {
latency := time.Since(start)
defer func() {
latency := time.Since(start)
reqID, _ := ctx.Value(middleware.RequestIDKey).(string)
reqID, _ := ctx.Value(
chimw.RequestIDKey,
).(string)
s.log.InfoContext(ctx, "request",
"request_start", start,
"method", r.Method,
"url", r.URL.String(),
"useragent", r.UserAgent(),
"request_id", reqID,
"referer", r.Referer(),
"proto", r.Proto,
"remoteIP", ipFromHostPort(r.RemoteAddr),
"status", lrw.statusCode,
"latency_ms", latency.Milliseconds(),
)
}()
mware.log.InfoContext(
ctx, "request",
"request_start", start,
"method", request.Method,
"url", request.URL.String(),
"useragent", request.UserAgent(),
"request_id", reqID,
"referer", request.Referer(),
"proto", request.Proto,
"remoteIP",
ipFromHostPort(request.RemoteAddr),
"status", lrw.statusCode,
"latency_ms",
latency.Milliseconds(),
)
}()
next.ServeHTTP(lrw, r)
})
next.ServeHTTP(lrw, request)
})
}
}
// CORS returns middleware that handles Cross-Origin Resource Sharing.
func (s *Middleware) CORS() func(http.Handler) http.Handler {
return cors.Handler(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
func (mware *Middleware) CORS() func(http.Handler) http.Handler {
return cors.Handler(cors.Options{ //nolint:exhaustruct // optional fields
AllowedOrigins: []string{"*"},
AllowedMethods: []string{
"GET", "POST", "PUT", "DELETE", "OPTIONS",
},
AllowedHeaders: []string{
"Accept", "Authorization",
"Content-Type", "X-CSRF-Token",
},
ExposedHeaders: []string{"Link"},
AllowCredentials: false,
MaxAge: corsMaxAge,
@ -120,28 +143,34 @@ func (s *Middleware) CORS() func(http.Handler) http.Handler {
}
// Auth returns middleware that performs authentication.
func (s *Middleware) Auth() func(http.Handler) http.Handler {
func (mware *Middleware) Auth() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.log.Info("AUTH: before request")
next.ServeHTTP(w, r)
})
return http.HandlerFunc(
func(
writer http.ResponseWriter,
request *http.Request,
) {
mware.log.Info("AUTH: before request")
next.ServeHTTP(writer, request)
})
}
}
// Metrics returns middleware that records HTTP metrics.
func (s *Middleware) Metrics() func(http.Handler) http.Handler {
mdlw := ghmm.New(ghmm.Config{
Recorder: metrics.NewRecorder(metrics.Config{}),
func (mware *Middleware) Metrics() func(http.Handler) http.Handler {
metricsMiddleware := ghmm.New(ghmm.Config{ //nolint:exhaustruct // optional fields
Recorder: metrics.NewRecorder(
metrics.Config{}, //nolint:exhaustruct // defaults
),
})
return func(next http.Handler) http.Handler {
return std.Handler("", mdlw, next)
return std.Handler("", metricsMiddleware, next)
}
}
// MetricsAuth returns middleware that protects metrics with basic auth.
func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
func (mware *Middleware) MetricsAuth() func(http.Handler) http.Handler {
return basicauth.New(
"metrics",
map[string][]string{

127
internal/server/routes.go
View File

@ -17,67 +17,94 @@ import (
const routeTimeout = 60 * time.Second
// SetupRoutes configures the HTTP routes and middleware.
func (s *Server) SetupRoutes() {
s.router = chi.NewRouter()
func (srv *Server) SetupRoutes() {
srv.router = chi.NewRouter()
s.router.Use(middleware.Recoverer)
s.router.Use(middleware.RequestID)
s.router.Use(s.mw.Logging())
srv.router.Use(middleware.Recoverer)
srv.router.Use(middleware.RequestID)
srv.router.Use(srv.mw.Logging())
if viper.GetString("METRICS_USERNAME") != "" {
s.router.Use(s.mw.Metrics())
srv.router.Use(srv.mw.Metrics())
}
s.router.Use(s.mw.CORS())
s.router.Use(middleware.Timeout(routeTimeout))
srv.router.Use(srv.mw.CORS())
srv.router.Use(middleware.Timeout(routeTimeout))
if s.sentryEnabled {
sentryHandler := sentryhttp.New(sentryhttp.Options{
Repanic: true,
})
s.router.Use(sentryHandler.Handle)
if srv.sentryEnabled {
sentryHandler := sentryhttp.New(
sentryhttp.Options{ //nolint:exhaustruct // optional fields
Repanic: true,
},
)
srv.router.Use(sentryHandler.Handle)
}
// Health check
s.router.Get(
// Health check.
srv.router.Get(
"/.well-known/healthcheck.json",
s.h.HandleHealthCheck(),
srv.handlers.HandleHealthCheck(),
)
// Protected metrics endpoint
// Protected metrics endpoint.
if viper.GetString("METRICS_USERNAME") != "" {
s.router.Group(func(r chi.Router) {
r.Use(s.mw.MetricsAuth())
r.Get("/metrics",
srv.router.Group(func(router chi.Router) {
router.Use(srv.mw.MetricsAuth())
router.Get("/metrics",
http.HandlerFunc(
promhttp.Handler().ServeHTTP,
))
})
}
// API v1
s.router.Route("/api/v1", func(r chi.Router) {
r.Get("/server", s.h.HandleServerInfo())
r.Post("/session", s.h.HandleCreateSession())
r.Get("/state", s.h.HandleState())
r.Get("/messages", s.h.HandleGetMessages())
r.Post("/messages", s.h.HandleSendCommand())
r.Get("/history", s.h.HandleGetHistory())
r.Get("/channels", s.h.HandleListAllChannels())
r.Get(
"/channels/{channel}/members",
s.h.HandleChannelMembers(),
)
})
// API v1.
srv.router.Route(
"/api/v1",
func(router chi.Router) {
router.Get(
"/server",
srv.handlers.HandleServerInfo(),
)
router.Post(
"/session",
srv.handlers.HandleCreateSession(),
)
router.Get(
"/state",
srv.handlers.HandleState(),
)
router.Get(
"/messages",
srv.handlers.HandleGetMessages(),
)
router.Post(
"/messages",
srv.handlers.HandleSendCommand(),
)
router.Get(
"/history",
srv.handlers.HandleGetHistory(),
)
router.Get(
"/channels",
srv.handlers.HandleListAllChannels(),
)
router.Get(
"/channels/{channel}/members",
srv.handlers.HandleChannelMembers(),
)
},
)
// Serve embedded SPA
s.setupSPA()
// Serve embedded SPA.
srv.setupSPA()
}
func (s *Server) setupSPA() {
func (srv *Server) setupSPA() {
distFS, err := fs.Sub(web.Dist, "dist")
if err != nil {
s.log.Error(
srv.log.Error(
"failed to get web dist filesystem",
"error", err,
)
@ -87,38 +114,40 @@ func (s *Server) setupSPA() {
fileServer := http.FileServer(http.FS(distFS))
s.router.Get("/*", func(
w http.ResponseWriter,
r *http.Request,
srv.router.Get("/*", func(
writer http.ResponseWriter,
request *http.Request,
) {
readFS, ok := distFS.(fs.ReadFileFS)
if !ok {
fileServer.ServeHTTP(w, r)
fileServer.ServeHTTP(writer, request)
return
}
f, readErr := readFS.ReadFile(r.URL.Path[1:])
if readErr != nil || len(f) == 0 {
fileData, readErr := readFS.ReadFile(
request.URL.Path[1:],
)
if readErr != nil || len(fileData) == 0 {
indexHTML, indexErr := readFS.ReadFile(
"index.html",
)
if indexErr != nil {
http.NotFound(w, r)
http.NotFound(writer, request)
return
}
w.Header().Set(
writer.Header().Set(
"Content-Type",
"text/html; charset=utf-8",
)
w.WriteHeader(http.StatusOK)
_, _ = w.Write(indexHTML)
writer.WriteHeader(http.StatusOK)
_, _ = writer.Write(indexHTML)
return
}
fileServer.ServeHTTP(w, r)
fileServer.ServeHTTP(writer, request)
})
}

144
internal/server/server.go
View File

@ -41,7 +41,8 @@ type Params struct {
Handlers *handlers.Handlers
}
// Server is the main HTTP server. It manages routing, middleware, and lifecycle.
// Server is the main HTTP server.
// It manages routing, middleware, and lifecycle.
type Server struct {
startupTime time.Time
exitCode int
@ -53,21 +54,24 @@ type Server struct {
router *chi.Mux
params Params
mw *middleware.Middleware
h *handlers.Handlers
handlers *handlers.Handlers
}
// New creates a new Server and registers its lifecycle hooks.
func New(lc fx.Lifecycle, params Params) (*Server, error) {
s := new(Server)
s.params = params
s.mw = params.Middleware
s.h = params.Handlers
s.log = params.Logger.Get()
func New(
lifecycle fx.Lifecycle, params Params,
) (*Server, error) {
srv := &Server{ //nolint:exhaustruct // fields set during lifecycle
params: params,
mw: params.Middleware,
handlers: params.Handlers,
log: params.Logger.Get(),
}
lc.Append(fx.Hook{
lifecycle.Append(fx.Hook{
OnStart: func(_ context.Context) error {
s.startupTime = time.Now()
go s.Run() //nolint:contextcheck
srv.startupTime = time.Now()
go srv.Run() //nolint:contextcheck
return nil
},
@ -76,122 +80,140 @@ func New(lc fx.Lifecycle, params Params) (*Server, error) {
},
})
return s, nil
return srv, nil
}
// Run starts the server configuration, Sentry, and begins serving.
func (s *Server) Run() {
s.configure()
s.enableSentry()
s.serve()
func (srv *Server) Run() {
srv.configure()
srv.enableSentry()
srv.serve()
}
// ServeHTTP delegates to the chi router.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.router.ServeHTTP(w, r)
func (srv *Server) ServeHTTP(
writer http.ResponseWriter,
request *http.Request,
) {
srv.router.ServeHTTP(writer, request)
}
// MaintenanceMode reports whether the server is in maintenance mode.
func (s *Server) MaintenanceMode() bool {
return s.params.Config.MaintenanceMode
func (srv *Server) MaintenanceMode() bool {
return srv.params.Config.MaintenanceMode
}
func (s *Server) enableSentry() {
s.sentryEnabled = false
func (srv *Server) enableSentry() {
srv.sentryEnabled = false
if s.params.Config.SentryDSN == "" {
if srv.params.Config.SentryDSN == "" {
return
}
err := sentry.Init(sentry.ClientOptions{
Dsn: s.params.Config.SentryDSN,
Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version),
err := sentry.Init(sentry.ClientOptions{ //nolint:exhaustruct // only essential fields
Dsn: srv.params.Config.SentryDSN,
Release: fmt.Sprintf(
"%s-%s",
srv.params.Globals.Appname,
srv.params.Globals.Version,
),
})
if err != nil {
s.log.Error("sentry init failure", "error", err)
srv.log.Error("sentry init failure", "error", err)
os.Exit(1)
}
s.log.Info("sentry error reporting activated")
s.sentryEnabled = true
srv.log.Info("sentry error reporting activated")
srv.sentryEnabled = true
}
func (s *Server) serve() int {
s.ctx, s.cancelFunc = context.WithCancel(context.Background())
func (srv *Server) serve() int {
srv.ctx, srv.cancelFunc = context.WithCancel(
context.Background(),
)
go func() {
c := make(chan os.Signal, 1)
sigCh := make(chan os.Signal, 1)
signal.Ignore(syscall.SIGPIPE)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
sig := <-c
s.log.Info("signal received", "signal", sig)
signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
if s.cancelFunc != nil {
s.cancelFunc()
sig := <-sigCh
srv.log.Info("signal received", "signal", sig)
if srv.cancelFunc != nil {
srv.cancelFunc()
}
}()
go s.serveUntilShutdown()
go srv.serveUntilShutdown()
<-s.ctx.Done()
<-srv.ctx.Done()
s.cleanShutdown()
srv.cleanShutdown()
return s.exitCode
return srv.exitCode
}
func (s *Server) cleanupForExit() {
s.log.Info("cleaning up")
func (srv *Server) cleanupForExit() {
srv.log.Info("cleaning up")
}
func (s *Server) cleanShutdown() {
s.exitCode = 0
func (srv *Server) cleanShutdown() {
srv.exitCode = 0
ctxShutdown, shutdownCancel := context.WithTimeout(
context.Background(), shutdownTimeout,
)
err := s.httpServer.Shutdown(ctxShutdown)
err := srv.httpServer.Shutdown(ctxShutdown)
if err != nil {
s.log.Error("server clean shutdown failed", "error", err)
srv.log.Error(
"server clean shutdown failed", "error", err,
)
}
if shutdownCancel != nil {
shutdownCancel()
}
s.cleanupForExit()
srv.cleanupForExit()
if s.sentryEnabled {
if srv.sentryEnabled {
sentry.Flush(sentryFlushTime)
}
}
func (s *Server) configure() {
// server configuration placeholder
func (srv *Server) configure() {
// Server configuration placeholder.
}
func (s *Server) serveUntilShutdown() {
listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
s.httpServer = &http.Server{
func (srv *Server) serveUntilShutdown() {
listenAddr := fmt.Sprintf(
":%d", srv.params.Config.Port,
)
srv.httpServer = &http.Server{ //nolint:exhaustruct // optional fields
Addr: listenAddr,
ReadTimeout: httpReadTimeout,
WriteTimeout: httpWriteTimeout,
MaxHeaderBytes: maxHeaderBytes,
Handler: s,
Handler: srv,
}
s.SetupRoutes()
srv.SetupRoutes()
s.log.Info("http begin listen", "listenaddr", listenAddr)
srv.log.Info(
"http begin listen", "listenaddr", listenAddr,
)
err := s.httpServer.ListenAndServe()
err := srv.httpServer.ListenAndServe()
if err != nil && !errors.Is(err, http.ErrServerClosed) {
s.log.Error("listen error", "error", err)
srv.log.Error("listen error", "error", err)
if s.cancelFunc != nil {
s.cancelFunc()
if srv.cancelFunc != nil {
srv.cancelFunc()
}
}
}